[lld] Teach LLD how to parse complete linker scripts

[rafaelauler]

Summary

This patch does *not* implement any semantic actions, but it is a first step to
teach LLD how to read complete linker scripts. The additional linker scripts
statements whose parsing is now supported are:

SEARCH_DIR directive
SECTIONS directive
Symbol definitions inside SECTIONS including PROVIDE and PROVIDE_HIDDEN
C-like expressions used in many places in linker scripts
Input to output sections mapping
The goal of this patch was guided towards completely parsing a default GNU ld
linker script and the linker script used to link the FreeBSD kernel. Thus, it
also adds a test case based on the default linker script used in GNU ld for
x86_64 ELF targets.

Note: Sorry for the size of this patch. I started with the goal of incrementally
developing this parser but ultimately failed. On the other side, the logic of the
parser is kind of repetitive, as one would expect, so this patch does not feature
lots of new things.

[rafaelauler]

I'll address a comment from Rui:

"ruiu added a comment.Via Web · Fri, Oct 17, 9:28 PM
Because this is a large patch, it'll take some time to review.
Let me send out my first comment in the meantime.

Inline Comments
include/lld/ReaderWriter/LinkerScript.h
402
Is there any reason to have these member functions to mutate object's fields? It seems to me that we can make the constructor to take all these values. If we do so, we can handle all BinOps as const, which helps readers to understand the code.

The same comments are applied to all other classes representing ast nodes."

Sure, I agree. I'll try to eliminate these setters as much as possible and upload a new patch.

[shankarke]

Could you add test cases that test for invalid linker scripts as well ?

lib/ReaderWriter/LinkerScript.cpp

991–993

can you convert the assert messages to appropriate error messages that can be displayed to the user ?

[rafaelauler]

Hi Shankar,

Thanks for your input. I agree and will update the patch according your suggestions.

[rafaelauler]

I changed the AST nodes creation according to Rui's suggestion.
I converted some asserts to error messages, according to Shankar's suggestion. There are still some asserts left that are only to check code sanity and are not appropriate for error messages.
I added test cases that exercises parsing errors (incomplete linker scripts) according to Shankar's suggestion.
I also changed the expression parsing functions to eliminate duplicated code and make it simpler.

[• shankar.easwaran]

LGTM

[ruiu]

I'll review this patch today. Please hold on for a while. Thanks.

[rafaelauler]

No problem, Rui, I was waiting for your feedback too. Thanks for putting in time to see this.

[ruiu]

include/lld/ReaderWriter/LinkerScript.h

323

Remove three blank lines above.

334

Is constant always unsigned?

394

sort

469

Can you make this enum class?

480

Add an example to the comment. My understanding of this class is it is representing ".text" or "SORT(.text*)" in

SECTIONS {
  .x: {  .text }
  .y { SORT(.text*) }
}

537

example here.

569

example here

607

Or, instead of adding example here, a link to the documentation is better?

For this, https://sourceware.org/binutils/docs/ld/Overlay-Description.html#Overlay-Description

617

Remove

730

In this patch you pass only 1 to this function. Do you really need to look ahead arbitrary number of tokens? The buffer management looks a bit too complicated to me.

775

You want to mention that identifier and "(" were already read.

812

I think we don't usually use \p notation.

lib/ReaderWriter/LinkerScript.cpp

85

sort

97

I think there's an implicit conversion from std::error_code to llvm::ErrorOr. So you can just write

return std::errc::io_error

100

return res;

135

You can write

else if (c >= 'A' && c <= 'F')
  res += c - 'A' + 10;
else
  return llvm::ErrorOr<uint64_t>(std::make_error_code(std::errc::io_error));

148

This needs to be case insensitive.

157

Instead of using two boolean values, you can define variable multiplier and set 1024 for K or 1024*1024 for M.

172

Huh, I didn't know that the linker script supports this way of writing a number. Good to know.

177

startswith_lower

191

Use early return here.

if (res.getError())
   return res;

195

and multiply by the multiplier

212

return '0' <= c && c <= '9'

254

You want to write multiple cases in one line. Or if expression may be shorter.

352

I think we need a function something like

drop(StringRef &s, int n)

that (destructively) drops n characters from s and returns them.

440–441

This line should be before default and

case '"': case '\'':

468

This expression

(_buffer.startswith("0x") && _buffer.size() > 2 && canContinueNumber(_buffer[2])

seems redundant, because if a string starts with "0x", it will always satisfy

canStartNumber(_buffer[0])

530

Sort

725

return 1;

735

Did you forget to add the trailing "("?

739

Ditto

837

remove space before \n

1263

This can be

if (peek(1)._kind == Token::l_paren)
  return parseFunctionCall();
Symbol *sym = ...
...
return sym;

1378

Remove this if

1384

s/LHS/lhs/

1402

s/RHS/rhs/

1405

Move consumeToken()s after this switch statement.

1410

lhs

1633

remove

[ruiu]

include/lld/ReaderWriter/LinkerScript.h

68

Sort in asciii-betical order.

121

It should be done in a different patch, but these can* member functions have nothing to do with the Lexer class (they don't use member variables of the class etc). These should be non-member function.

158

Sort.

[rafaelauler]

Hi Rui,

I appreciate the thorough review, thanks! I implemented your suggestions and will upload a new patch now.

include/lld/ReaderWriter/LinkerScript.h

68

Done

121

I agree, I will submit another patch soon.

158

Done

323

Done.

334

Added the following comment to explain this:
/ A constant value is stored as unsigned because it represents absolute
/ values. We represent negative numbers by composing the unary '-' operator
/// with a constant.

I also added the UnaryMinus class to represent negative numbers and properly updated the parser, thanks for pointing out.

394

Done

469

Done

480

Done

537

Done

569

Done

607

Done

617

Done

730

I agree. I changed this algorithm to only peek at the next token. I originally wrote this function to perform arbitrary look ahead because I was not sure if the linker script grammar would need it. Currently, I believe we won't need this in the future, so I modified this function to always peek the next token, which is a much simpler problem. If we ever come across the need to look ahead more than 1 token, I'll resubmit this complete algorithm again.

775

Sorry, I'm not sure if I understood your observation here, you see, parseFunctionCall() is responsible for consuming this entire expression, including identifier and left paren.

812

No problem, removed.

lib/ReaderWriter/LinkerScript.cpp

85

Done

97

Thanks for the tip!

100

Fixed

135

Indeed, thanks, updated it.

148

OK. I don't think that StringSwitch has something like StartsWithLower, so I just added another case.

157

Fair, changed it.

177

Fixed

191

Done

195

OK

212

Fixed

254

In fact I did with multiple cases, but clang-format undid it :-) will fix it.

352

Good idea. Done.

440–441

Done

468

Fixed.

530

Done

725

Done

735

Right, thanks

739

Fixed

837

Fixed

1263

Fixed

1378

Done

1384

Fixed

1402

Fixed

1405

Done

1410

Fixed

1633

Removed

[rafaelauler]

Implemented Rui's suggestions.

[silvas]

Note: Sorry for the size of this patch. I started with the goal of incrementally
developing this parser but ultimately failed. On the other side, the logic of the
parser is kind of repetitive, as one would expect, so this patch does not feature
lots of new things.

It's totally OK (and I think normal) to go back and split the history into incremental pieces after the fact if you are unhappy with the patch size. That way, you can still get the same high-quality code review that you would have gotten by incrementally developing it, which is most of the benefit of the incremental approach.

As a sanity check, I would also recommend running this over all the linker scripts in the linux kernel and the linker scripts from a typical embedded application. If you haven't already, definitely take a read through http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-December/057421.html

Also, to test your "dump" functionality, you should verify that the various projects still work if you replace the real scripts with "dump"ed scripts.

In test/LinkerScript/sections.test, it looks like you directly used the tool output as the expected output for the test. This doesn't give any confidence in the correctness by itself; if you haven't already done so, definitely try to build some code using the dumped script in place of the real script as a sanity check.

Also, please add links (or at least mention) any resources you used when developing this. What did you use as your "langref"? In the future, somebody is going to have to debug this code and they need to be able to determine if it is doing the right thing (or what the right thing is supposed to be).

lib/ReaderWriter/LinkerScript.cpp

467–481

Don't use doxygen comments inside the function. Here and elsewhere.

test/LinkerScript/expr-precedence.test

28–33

Having the token dump together with the AST dump is really gross. Could you commit a separate patch that enhances linker-script-test to have two different modes and then clean up these test cases?

test/LinkerScript/missing-operand.test

20

FileCheck has some special functionality for checking diagnostics that avoids the need to hard-code absolute line numbers. You should use it: http://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-expressions

Also, it should be pretty easy to do caret diagnostics.

[rafaelauler]

Hi Sean, thanks for your input, I didn't know your write-up about linker scripts, it's great!

I'll check the dumped scripts for correct behavior. I put in a comment the reference I used to implement the parser (see LinkerScript.h:692); it's the GNU manual, e.g. https://sourceware.org/binutils/docs/ld/SECTIONS.html#SECTIONS.

I'll work on your suggestions.

[rafaelauler]

Addressed Sean's concerns and tested the dump'ed scripts. This required adjusting some cosmetic issues to make dump'ed scripts 100% parseable by GNU ld. Also added other missing features to parse other kernel linker scripts: unary negation, fill expressions that can be indefinitely large ( =0x909090909090909090909090) and parsing symbol assignments outside SECTIONS.

Sanity checks performed: I tested SPEC userland programs linked by GNU ld, using the linker script dump'ed by this parser, and everything went fine.
I then tested linking the FreeBSD kernel with a dump'ed linker script, installed the new kernel and booted it, everything went fine.

Successfully parsed all linker scripts from the FreeBSD kernel, except ldscript.mips.cfe and ldscript.mips.octeon, which requires the PHDRS command (not implemented yet).

Things not tested: embedded scenarios, since this parser currently does not support the MEMORY command, common in these scenarios.

[shankarke]

include/lld/ReaderWriter/LinkerScript.h

42–68

All of the above need to have a prefix.Also you may need to sort all the enumerated constants like others to be consistent.

http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

276

const StringRef => StringRef everywhere.

295

remove const StringRef, StringRef is const already

335

explicit Constant ? There are other classes that would need explicit as well.

400–412

There are enums which are not classes, and some enums which are plain enums. We would need to be consistent.

Rename the enumeration names as documented in the convention.

http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

432–437

Can you add comment on whats the depth of the ternary condition thats supported as well as an example like how you document other commands.

434

explicit again.

464–465

look at previous comments on enums.

657–667

From your tests, do you see any that uses Overlay command ?

lib/ReaderWriter/LinkerScript.cpp

92–139

Could you move all the above functions to lld/Support ? These functions may be useful for even command line parsing for example to support --section-start as well as for other flavors.

308–312

How will this perform ? For large linker scripts drop_front is going to be repeatedly called for every token.

577–582

move this inside the class itself.

754–757

move this inside the class itself.

[rafaelauler]

Hi Shankar,
Glad you made a second round of suggestions, thanks. I answered some of your concerns below, but will also work on your suggestions and update the patch soon.

Best regards,
Rafael Auler

include/lld/ReaderWriter/LinkerScript.h

42–68

I just kept the coding style I found in this file, whose original author is not me. For me, it's no problem to convert this to the official LLVM naming convention.

This enum is already sorted according to Rui's suggestion, by using the ASCII table order.

Correct me if I'm wrong, but I think we can drop the prefix here, according to official LLVM naming rules. If the enum is inside a class, the prefix is not necessary.

276

You're right! Thanks for spotting this!

335

I agree, will do, thanks.

400–412

I guess the criteria was to use enum classes when the enum is defined outside a class, like the one Rui pointed out.

Correct me if I'm wrong, but I think this enum already follows the LLVM standard -- when the enum is inside a class, we may drop the prefix, i.e.: And instead of O_And.

432–437

Will do.

657–667

None. Do you think it's better to remove this, for now?

lib/ReaderWriter/LinkerScript.cpp

308–312

This should be inlined, in fact, it was just a refactoring suggested by Rui that would enable us to write simpler code in the next lines. You're right though, it will be called a lot. On the other hand, I don't think that this code is bad-performing: substr() will just update the size of in the StringRef object and drop_front() will directly compute a new StringRef pointer and return it (pointer arithmetic) and update size as well. But I can profile this and discover if this is a limitation.

577–582

Should we leave these as virtual anchors in the C++ code or is this not a concern for the LLD project?

[shankarke]

include/lld/ReaderWriter/LinkerScript.h

42–68

We are following a mixed pattern here, for some we use a kw_ to start the enumeration with, there are _(underscore patterns) and non underscore patterns, I am not sure on what we want to rename but I think it would be nice if we are consistent in naming the enumerations ?

657–667

leave it for now, at the time of Layout we could say this command is not supported :)

lib/ReaderWriter/LinkerScript.cpp

577–582

Leave them as virtual anchors still.

[ruiu]

Seems this patch is good enough to land. We may be able to improve it even more but that can be done in a different patch.

As you mentioned, this patch was too large. It could have been split into small incremental patches, each adding syntactic element one by one. This patch was fortunately not risky, but if it was and we couldn't agree that this should land, you might have wasted your time. So please start with a small patch next time. Thanks!

include/lld/ReaderWriter/LinkerScript.h

42–68

Seems only keyword (e.g. "align" or "as_needed") starts with kw_ prefix. That looks fine and this code follows the coding style. I don't see non-keyword (e.g. = or +) needs prefix.

434

This constructor has three parameters so explicit keyword is not needed.

[silvas]

A couple nits, but I agree with Rui that this is good to land.

lib/ReaderWriter/LinkerScript.cpp

586–592

fwiw, my favorite pattern for doing this "intersperse with commas" operation is:

for (int i = 0, e = _args.size(); i != e; ++i) {
  if (i)
    os << ", ";
  _args[i]->dump(os);
}

It's a bit cleaner than the pattern you're currently using.

1617–1621

You use this simpler pattern elsewhere:

for (int i = 0; i != numParen; ++i)
  if (!expectAndConsume(Token::r_paren, "expected )"))
    return nullptr;

also, just above you use this more complicated if-while pattern.

[rafaelauler]

Thanks Sean and Rui for your code review.

lib/ReaderWriter/LinkerScript.cpp

586–592

Nice one, will use it.

1617–1621

Makes sense, I will change this code to use the simpler pattern

[• shankar.easwaran]

LGTM

[rafaelauler]

Committed revision 221126.

include/lld/ReaderWriter/LinkerScript.h

 
 namespace lld {
 namespace script {
 class Token {
 public:
   enum Kind {
     unknown,
     eof,
-    identifier,
-    libname,
-    comma,
+    exclaim,
+    exclaimequal,
+    amp,
+    ampequal,
     l_paren,
     r_paren,
+    star,
+    starequal,
+    plus,
+    plusequal,
+    comma,
+    minus,
+    minusequal,
+    slash,
+    slashequal,
+    number,
+    colon,
+    semicolon,
+    less,
+    lessequal,
+    lessless,
+    lesslessequal,
+    equal,
+    equalequal,
+    greater,
+    greaterequal,
+    greatergreater,
+    greatergreaterequal,
+    question,
+    identifier,
+    libname,
+    kw_align,
+    kw_align_with_input,
+    kw_as_needed,
+    kw_at,
+    kw_discard,
     kw_entry,
+    kw_exclude_file,
     kw_group,
-    kw_output_format,
+    kw_hidden,
+    kw_keep,
+    kw_provide,
+    kw_provide_hidden,
+    kw_only_if_ro,
+    kw_only_if_rw,
     kw_output_arch,
-    kw_as_needed
+    kw_output_format,
+    kw_overlay,
+    kw_search_dir,
+    kw_sections,
+    kw_sort_by_alignment,
+    kw_sort_by_init_priority,
+    kw_sort_by_name,
+    kw_sort_none,
+    kw_subalign,
+    l_brace,
+    pipe,
+    pipeequal,
+    r_brace,
+    tilde
   };
 
   Token() : _kind(unknown) {}
   Token(StringRef range, Kind kind) : _range(range), _kind(kind) {}
 
   void dump(raw_ostream &os) const;
 
   StringRef _range;
   Kind _kind;
 };
 
 class Lexer {
 public:
-  explicit Lexer(std::unique_ptr<MemoryBuffer> mb)
-      : _buffer(mb->getBuffer()) {
+  explicit Lexer(std::unique_ptr<MemoryBuffer> mb) : _buffer(mb->getBuffer()) {
     _sourceManager.AddNewSourceBuffer(std::move(mb), llvm::SMLoc());
   }
 
   void lex(Token &tok);
 
   const llvm::SourceMgr &getSourceMgr() const { return _sourceManager; }
 
 private:
+  bool canStartNumber(char c) const;
+  bool canContinueNumber(char c) const;
   bool canStartName(char c) const;
   bool canContinueName(char c) const;
   void skipWhitespace();
 
   Token _current;
   /// \brief The current buffer state.
   StringRef _buffer;
   // Lexer owns the input files.
   llvm::SourceMgr _sourceManager;
 };
 
+/// All linker scripts commands derive from this class. High-level, sections and
+/// output section commands are all subclasses of this class.
+/// Examples:
+///
+/// OUTPUT_FORMAT("elf64-x86-64") /* A linker script command */
+/// OUTPUT_ARCH(i386:x86-64)      /* Another command */
+/// ENTRY(_start)                 /* Another command */
+///
+/// SECTIONS                      /* Another command */
+/// {
+///   .interp : {                 /* A sections-command */
+///              *(.interp)       /* An output-section-command */
+///              }
+///  }
+///
 class Command {
 public:
-  enum class Kind { Entry, OutputFormat, OutputArch, Group, };
+  enum class Kind {
+    Entry,
+    Group,
+    InputSectionsCmd,
+    OutputArch,
+    OutputFormat,
+    OutputSectionDescription,
+    Overlay,
+    SearchDir,
+    Sections,
+    SymbolAssignment,
+  };
 
   Kind getKind() const { return _kind; }
 
   virtual void dump(raw_ostream &os) const = 0;
 
   virtual ~Command() {}
 
 protected:
public:
 
   void dump(raw_ostream &os) const override {
     os << "OUTPUT_FORMAT(";
     bool first = true;
     for (StringRef format : _formats) {
       if (!first)
         os << ",";
       first = false;
-      os << format;
+      os << "\"" << format << "\"";
     }
     os << ")\n";
   }
 
   virtual void addOutputFormat(StringRef format) { _formats.push_back(format); }
 
   range<StringRef *> getFormats() { return _formats; }
 
 private:
   std::vector<StringRef> _formats;
 };
 
 class OutputArch : public Command {
 public:
   explicit OutputArch(StringRef arch)
       : Command(Kind::OutputArch), _arch(arch) {}
 
   static bool classof(const Command *c) {
     return c->getKind() == Kind::OutputArch;
   }
 
   void dump(raw_ostream &os) const override {
-    os << "OUTPUT_arch(" << getArch() << ")\n";
+    os << "OUTPUT_ARCH(" << getArch() << ")\n";
   }
 
   StringRef getArch() const { return _arch; }
 
 private:
   StringRef _arch;
 };
 
 struct Path {
   StringRef _path;
   bool _asNeeded;
   bool _isDashlPrefix;
 
   Path() : _asNeeded(false), _isDashlPrefix(false) {}
   explicit Path(StringRef path, bool asNeeded = false, bool isLib = false)
       : _path(path), _asNeeded(asNeeded), _isDashlPrefix(isLib) {}
 };
 
 class Group : public Command {
 public:
-  template <class RangeT>
-  explicit Group(RangeT range) : Command(Kind::Group) {
+  template <class RangeT> explicit Group(RangeT range) : Command(Kind::Group) {
     std::copy(std::begin(range), std::end(range), std::back_inserter(_paths));
   }
 
   static bool classof(const Command *c) { return c->getKind() == Kind::Group; }
 
   void dump(raw_ostream &os) const override {
     os << "GROUP(";
     bool first = true;
public:
   const std::vector<Path> &getPaths() const { return _paths; }
 
 private:
   std::vector<Path> _paths;
 };
 
 class Entry : public Command {
 public:
-  explicit Entry(StringRef entryName) :
-      Command(Kind::Entry), _entryName(entryName) { }
+  explicit Entry(StringRef entryName)
+      : Command(Kind::Entry), _entryName(entryName) {}
+
+  static bool classof(const Command *c) { return c->getKind() == Kind::Entry; }
+
+  void dump(raw_ostream &os) const override {
+    os << "ENTRY(" << _entryName << ")\n";
+  }
+
+  const StringRef getEntryName() const { return _entryName; }
+
+private:
+  StringRef _entryName;
+};
+
+class SearchDir : public Command {
+public:
+  explicit SearchDir(StringRef searchPath)
+      : Command(Kind::SearchDir), _searchPath(searchPath) {}
 
   static bool classof(const Command *c) {
-    return c->getKind() == Kind::Entry;
+    return c->getKind() == Kind::SearchDir;
   }
 
   void dump(raw_ostream &os) const override {
-    os << "ENTRY(" << _entryName << ")\n";
+    os << "SEARCH_DIR(\"" << _searchPath << "\")\n";
+  }
+
+  const StringRef getSearchPath() const { return _searchPath; }
+
+private:
+  StringRef _searchPath;
+};
+
+/// Superclass for expression nodes. Linker scripts accept C-like expressions in
+/// many places, such as when defining the value of a symbol or the address of
+/// an output section.
+/// Example:
+///
+/// SECTIONS {
+///   my_symbol = 1 + 1 * 2;
+///               | |     ^~~~> Constant : Expression
+///               | | ^~~~> Constant : Expression
+///               | |   ^~~~> BinOp : Expression
+///               ^~~~> Constant : Expression
+///                 ^~~~> BinOp : Expression  (the top-level Expression node)
+/// }
+///
+class Expression {
+public:
+  enum class Kind { Constant, Symbol, FunctionCall, Unary, BinOp,
+                    TernaryConditional };
+  Kind getKind() const { return _kind; }
+  virtual void dump(raw_ostream &os) const = 0;
+  virtual ~Expression() {}
+
+protected:
+  explicit Expression(Kind k) : _kind(k) {}
+
+private:
+  Kind _kind;
+};
+
+/// A constant value is stored as unsigned because it represents absolute
+/// values. We represent negative numbers by composing the unary '-' operator
+/// with a constant.
+class Constant : public Expression {
+public:
+  Constant(uint64_t num) : Expression(Kind::Constant), _num(num) {}
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Expression *c) {
+    return c->getKind() == Kind::Constant;
   }
 
-  const StringRef getEntryName() const {
-    return _entryName;
+private:
+  uint64_t _num;
+};
+
+class Symbol : public Expression {
+public:
+  Symbol(StringRef name) : Expression(Kind::Symbol), _name(name) {}
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Expression *c) {
+    return c->getKind() == Kind::Symbol;
   }
 
 private:
-  StringRef _entryName;
+  StringRef _name;
+};
+
+class FunctionCall : public Expression {
+public:
+  template <class RangeT>
+  FunctionCall(StringRef name, RangeT range)
+      : Expression(Kind::FunctionCall), _name(name) {
+    std::copy(std::begin(range), std::end(range), std::back_inserter(_args));
+  }
+
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Expression *c) {
+    return c->getKind() == Kind::FunctionCall;
+  }
+
+private:
+  StringRef _name;
+  std::vector<const Expression *> _args;
+};
+
+class Unary : public Expression {
+public:
+  enum Operation {
+    Minus,
+    Not
+  };
+
+  Unary(Operation op, const Expression *child) : Expression(Kind::Unary),
+    _op(op), _child(child) {}
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Expression *c) {
+    return c->getKind() == Kind::Unary;
+  }
+
+private:
+  Operation _op;
+  const Expression *_child;
+};
+
+class BinOp : public Expression {
+public:
+  enum Operation {
+    And,
+    CompareDifferent,
+    CompareEqual,
+    CompareGreater,
+    CompareGreaterEqual,
+    CompareLess,
+    CompareLessEqual,
+    Div,
+    Mul,
+    Or,
+    Shl,
+    Shr,
+    Sub,
+    Sum
+  };
+
+  BinOp(const Expression *lhs, Operation op, const Expression *rhs)
+      : Expression(Kind::BinOp), _op(op), _lhs(lhs), _rhs(rhs) {}
+
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Expression *c) {
+    return c->getKind() == Kind::BinOp;
+  }
+
+private:
+  Operation _op;
+  const Expression *_lhs;
+  const Expression *_rhs;
+};
+
+class TernaryConditional : public Expression {
+public:
+  TernaryConditional(const Expression *conditional, const Expression *trueExpr,
+                     const Expression *falseExpr)
+      : Expression(Kind::TernaryConditional), _conditional(conditional),
+        _trueExpr(trueExpr), _falseExpr(falseExpr) {}
+
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Expression *c) {
+    return c->getKind() == Kind::TernaryConditional;
+  }
+
+private:
+  const Expression *_conditional;
+  const Expression *_trueExpr;
+  const Expression *_falseExpr;
+};
+
+/// Symbol assignments of the form "symbolname = <expression>" may occur either
+/// as sections-commands or as output-section-commands.
+/// Example:
+///
+/// SECTIONS {
+///   mysymbol = .         /* SymbolAssignment as a sections-command */
+///   .data : {
+///     othersymbol = .    /* SymbolAssignment as an output-section-command */
+///   }
+///}
+///
+class SymbolAssignment : public Command {
+public:
+  enum AssignmentKind { Simple, Sum, Sub, Mul, Div, Shl, Shr, And, Or };
+  enum AssignmentVisibility { Normal, Hidden, Provide, ProvideHidden };
+
+  SymbolAssignment(StringRef name, const Expression *expr, AssignmentKind kind,
+                   AssignmentVisibility visibility)
+      : Command(Kind::SymbolAssignment), _expression(expr), _symbol(name),
+        _assignmentKind(Simple), _assignmentVisibility(visibility) {}
+
+  static bool classof(const Command *c) {
+    return c->getKind() == Kind::SymbolAssignment;
+  }
+
+  void dump(raw_ostream &os) const override;
+
+private:
+  const Expression *_expression;
+  StringRef _symbol;
+  AssignmentKind _assignmentKind;
+  AssignmentVisibility _assignmentVisibility;
+};
+
+/// Encodes how to sort file names or section names that are expanded from
+/// wildcard operators. This typically occurs in constructs such as
+/// SECTIONS {  .data : SORT_BY_NAME(*)(*) }}, where the order of the expanded
+/// names is important to determine which sections go first.
+enum class WildcardSortMode {
+  NA,
+  ByAlignment,
+  ByAlignmentAndName,
+  ByInitPriority,
+  ByName,
+  ByNameAndAlignment,
+  None
+};
+
+/// Represents either a single input section name or a group of sorted input
+/// section names. They specify which sections to map to a given output section.
+/// Example:
+///
+/// SECTIONS {
+///   .x: { *(.text) }
+///   /*      ^~~~^         InputSectionName : InputSection  */
+///   .y: { *(SORT(.text*)) }
+///   /*      ^~~~~~~~~~~^  InputSectionSortedGroup : InputSection  */
+/// }
+class InputSection {
+public:
+  enum class Kind { InputSectionName, SortedGroup };
+
+  Kind getKind() const { return _kind; }
+
+  virtual void dump(raw_ostream &os) const = 0;
+
+  virtual ~InputSection() {}
+
+protected:
+  explicit InputSection(Kind k) : _kind(k) {}
+
+private:
+  Kind _kind;
+};
+
+class InputSectionName : public InputSection {
+public:
+  InputSectionName(StringRef name, bool excludeFile)
+      : InputSection(Kind::InputSectionName), _name(name),
+        _excludeFile(excludeFile) {}
+
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const InputSection *c) {
+    return c->getKind() == Kind::InputSectionName;
+  }
+  bool hasExcludeFile() const { return _excludeFile; }
+
+private:
+  StringRef _name;
+  bool _excludeFile;
+};
+
+class InputSectionSortedGroup : public InputSection {
+public:
+  template <class RangeT>
+  InputSectionSortedGroup(WildcardSortMode sort, RangeT range)
+      : InputSection(Kind::SortedGroup), _sortMode(sort) {
+    std::copy(std::begin(range), std::end(range),
+              std::back_inserter(_sections));
+  }
+
+  void dump(raw_ostream &os) const override;
+  WildcardSortMode getSortMode() const { return _sortMode; }
+
+  static bool classof(const InputSection *c) {
+    return c->getKind() == Kind::SortedGroup;
+  }
+
+private:
+  WildcardSortMode _sortMode;
+  std::vector<const InputSection *> _sections;
+};
+
+/// An output-section-command that maps a series of sections inside a given
+/// file-archive pair to an output section.
+/// Example:
+///
+/// SECTIONS {
+///   .x: { *(.text) }
+///   /*    ^~~~~~~^ InputSectionsCmd   */
+///   .y: { w:z(SORT(.text*)) }
+///   /*    ^~~~~~~~~~~~~~~~^  InputSectionsCmd  */
+/// }
+class InputSectionsCmd : public Command {
+public:
+  typedef std::vector<const InputSection *> VectorTy;
+
+  template <class RangeT>
+  InputSectionsCmd(StringRef fileName, StringRef archiveName, bool keep,
+                   WildcardSortMode fileSortMode,
+                   WildcardSortMode archiveSortMode, RangeT range)
+      : Command(Kind::InputSectionsCmd), _fileName(fileName),
+        _archiveName(archiveName), _keep(keep), _fileSortMode(fileSortMode),
+        _archiveSortMode(archiveSortMode) {
+    std::copy(std::begin(range), std::end(range),
+              std::back_inserter(_sections));
+  }
+
+  void dump(raw_ostream &os) const override;
+
+  static bool classof(const Command *c) {
+    return c->getKind() == Kind::InputSectionsCmd;
+  }
+
+private:
+  StringRef _fileName;
+  StringRef _archiveName;
+  bool _keep;
+  WildcardSortMode _fileSortMode;
+  WildcardSortMode _archiveSortMode;
+  VectorTy _sections;
+};
+
+/// A sections-command to specify which input sections and symbols compose a
+/// given output section.
+/// Example:
+///
+/// SECTIONS {
+///   .x: { *(.text) ; symbol = .; }
+/// /*^~~~~~~~~~~~~~~~~~~~~~~~~~~~~^   OutputSectionDescription */
+///   .y: { w:z(SORT(.text*)) }
+/// /*^~~~~~~~~~~~~~~~~~~~~~~~^  OutputSectionDescription  */
+///   .a 0x10000 : ONLY_IF_RW { *(.data*) ; *:libc.a(SORT(*)); }
+/// /*^~~~~~~~~~~~~  OutputSectionDescription ~~~~~~~~~~~~~~~~~^ */
+/// }
+class OutputSectionDescription : public Command {
+public:
+  enum Constraint { C_None, C_OnlyIfRO, C_OnlyIfRW };
+
+  template <class RangeT>
+  OutputSectionDescription(StringRef sectionName, const Expression *address,
+                           const Expression *align, const Expression *subAlign,
+                           const Expression *at, const Expression *fillExpr,
+                           StringRef fillStream,
+                           bool alignWithInput, bool discard,
+                           Constraint constraint, RangeT range)
+      : Command(Kind::OutputSectionDescription), _sectionName(sectionName),
+        _address(address), _align(align), _subAlign(subAlign), _at(at),
+        _fillExpr(fillExpr), _fillStream(fillStream),
+        _alignWithInput(alignWithInput), _discard(discard),
+        _constraint(constraint) {
+    std::copy(std::begin(range), std::end(range),
+              std::back_inserter(_outputSectionCommands));
+  }
+
+  static bool classof(const Command *c) {
+    return c->getKind() == Kind::OutputSectionDescription;
+  }
+
+  void dump(raw_ostream &os) const override;
+
+private:
+  StringRef _sectionName;
+  const Expression *_address;
+  const Expression *_align;
+  const Expression *_subAlign;
+  const Expression *_at;
+  const Expression *_fillExpr;
+  StringRef _fillStream;
+  bool _alignWithInput;
+  bool _discard;
+  Constraint _constraint;
+  std::vector<const Command *> _outputSectionCommands;
+};
+
+/// Represents an Overlay structure as documented in
+/// https://sourceware.org/binutils/docs/ld/Overlay-Description.html#Overlay-Description
+class Overlay : public Command {
+public:
+  Overlay() : Command(Kind::Overlay) {}
+
+  static bool classof(const Command *c) {
+    return c->getKind() == Kind::Overlay;
+  }
+
+  void dump(raw_ostream &os) const override { os << "Overlay description\n"; }
 };
 
+/// Represents all the contents of the SECTIONS {} construct.
+class Sections : public Command {
+public:
+  template <class RangeT> Sections(RangeT range) : Command(Kind::Sections) {
+    std::copy(std::begin(range), std::end(range),
+              std::back_inserter(_sectionsCommands));
+  }
+
+  static bool classof(const Command *c) {
+    return c->getKind() == Kind::Sections;
+  }
+
+  void dump(raw_ostream &os) const override;
+
+private:
+  std::vector<const Command *> _sectionsCommands;
+};
+
+/// Stores the parse tree of a linker script.
 class LinkerScript {
 public:
   void dump(raw_ostream &os) const {
-    for (const Command *c : _commands)
+    for (const Command *c : _commands) {
       c->dump(os);
+      if (isa<SymbolAssignment>(c))
+        os << "\n";
+    }
   }
 
-  std::vector<Command *> _commands;
+  std::vector<const Command *> _commands;
 };
 
+/// Recognizes syntactic constructs of a linker script using a predictive
+/// parser/recursive descent implementation.
+///
+/// Based on the linker script documentation available at
+/// https://sourceware.org/binutils/docs/ld/Scripts.html
 class Parser {
 public:
-  explicit Parser(Lexer &lex) : _lex(lex) {}
+  explicit Parser(Lexer &lex) : _lex(lex), _peekAvailable(false) {}
 
   LinkerScript *parse();
 
 private:
-  void consumeToken() { _lex.lex(_tok); }
+  /// Advances to the next token, either asking the Lexer to lex the next token
+  /// or obtaining it from the look ahead buffer.
+  void consumeToken() {
+    // First check if the look ahead buffer cached the next token
+    if (_peekAvailable) {
+      _tok = _bufferedToken;
+      _peekAvailable = false;
+      return;
+    }
+    _lex.lex(_tok);
+  }
+
+  /// Returns the token that succeeds the current one without consuming the
+  /// current token. This operation will lex an additional token and store it in
+  /// a private buffer.
+  const Token &peek() {
+    if (_peekAvailable)
+      return _bufferedToken;
+
+    _lex.lex(_bufferedToken);
+    _peekAvailable = true;
+    return _bufferedToken;
+  }
 
   void error(const Token &tok, Twine msg) {
-    _lex.getSourceMgr()
-        .PrintMessage(llvm::SMLoc::getFromPointer(tok._range.data()),
-                      llvm::SourceMgr::DK_Error, msg);
+    _lex.getSourceMgr().PrintMessage(
+        llvm::SMLoc::getFromPointer(tok._range.data()),
   }
 
   bool expectAndConsume(Token::Kind kind, Twine msg) {
     if (_tok._kind != kind) {
       error(_tok, msg);
       return false;
     }
     consumeToken();
     return true;
   }
 
   bool isNextToken(Token::Kind kind) { return (_tok._kind == kind); }
 
+  // Recursive descent parsing member functions
+  // All of these functions consumes tokens and return an AST object,
+  // represented by the Command superclass. However, note that not all AST
+  // objects derive from Command. For nodes of C-like expressions, used in
+  // linker scripts, the superclass is Expression. For nodes that represent
+  // input sections that map to an output section, the superclass is
+  // InputSection.
+  //
+  // Example mapping common constructs to AST nodes:
+  //
+  // SECTIONS {             /* Parsed to Sections class */
+  //   my_symbol = 1 + 1;   /* Parsed to SymbolAssignment class */
+  //   /*          ^~~> Parsed to Expression class         */
+  //   .data : { *(.data) } /* Parsed to OutputSectionDescription class */
+  //   /*          ^~~> Parsed to InputSectionName class   */
+  //   /*        ^~~~~> Parsed to InputSectionsCmd class   */
+  // }
+
+  // ==== Expression parsing member functions ====
+
+  /// Parse "identifier(param [, param]...)"
+  ///
+  /// Example:
+  ///
+  /// SECTIONS {
+  ///   my_symbol = 0x1000 | ALIGN(other_symbol);
+  ///   /*                   ^~~~> parseFunctionCall()
+  /// }
+  const Expression *parseFunctionCall();
+
+  /// Ensures that the current token is an expression operand. If it is not,
+  /// issues an error to the user and returns false.
+  bool expectExprOperand();
+
+  /// Parse operands of an expression, such as function calls, identifiers,
+  /// literal numbers or unary operators.
+  ///
+  /// Example:
+  ///
+  /// SECTIONS {
+  ///   my_symbol = 0x1000 | ALIGN(other_symbol);
+  ///               ^~~~> parseExprTerminal()
+  /// }
+  const Expression *parseExprOperand();
+
+  // As a reference to the precedence of C operators, consult
+  // http://en.cppreference.com/w/c/language/operator_precedence
+
+  /// Parse either a single expression operand and returns or parse an entire
+  /// expression if its top-level node has a lower or equal precedence than the
+  /// indicated.
+  const Expression *parseExpression(unsigned precedence = 13);
+
+  /// Parse an operator and its rhs operand, assuming that the lhs was already
+  /// consumed. Keep parsing subsequent operator-operand pairs that do not
+  /// exceed highestPrecedence.
+  /// * lhs points to the left-hand-side operand of this operator
+  /// * maxPrecedence has the maximum operator precedence level that this parse
+  /// function is allowed to consume.
+  const Expression *parseOperatorOperandLoop(const Expression *lhs,
+                                             unsigned maxPrecedence);
+
+  /// Parse ternary conditionals such as "(condition)? true: false;". This
+  /// operator has precedence level 13 and associates right-to-left.
+  const Expression *parseTernaryCondOp(const Expression *lhs);
+
+  // ==== High-level commands parsing ====
+
+  /// Parse the OUTPUT_FORMAT linker script command.
+  /// Example:
+  ///
+  /// OUTPUT_FORMAT(elf64-x86-64,elf64-x86-64,elf64-x86-64)
+  /// ^~~~> parseOutputFormat()
+  ///
   OutputFormat *parseOutputFormat();
+
+  /// Parse the OUTPUT_ARCH linker script command.
+  /// Example:
+  ///
+  /// OUTPUT_ARCH(i386:x86-64)
+  /// ^~~~> parseOutputArch()
+  ///
   OutputArch *parseOutputArch();
+
+  /// Parse the GROUP linker script command.
+  /// Example:
+  ///
+  /// GROUP ( /lib/x86_64-linux-gnu/libc.so.6
+  ///         /usr/lib/x86_64-linux-gnu/libc_nonshared.a
+  ///         AS_NEEDED ( /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 )
+  ///         -lm -l:libgcc.a )
+  ///
   Group *parseGroup();
   bool parseAsNeeded(std::vector<Path> &paths);
+
+  /// Parse the ENTRY linker script command.
+  /// Example:
+  ///
+  /// ENTRY(init)
+  /// ^~~~> parseEntry()
+  ///
   Entry *parseEntry();
 
+  /// Parse the SEARCH_DIR linker script command.
+  /// Example:
+  ///
+  /// SEARCH_DIR("/usr/x86_64-linux-gnu/lib64");
+  /// ^~~~> parseSearchDir()
+  ///
+  SearchDir *parseSearchDir();
+
+  /// Parse "symbol = expression" commands that live inside the
+  /// SECTIONS directive.
+  /// Example:
+  ///
+  /// SECTIONS {
+  ///   my_symbol = 1 + 1;
+  ///               ^~~~> parseExpression()
+  ///   ^~~~ parseSymbolAssignment()
+  /// }
+  ///
+  const SymbolAssignment *parseSymbolAssignment();
+
+  /// Parse "EXCLUDE_FILE" used inside the listing of input section names.
+  /// Example:
+  ///
+  /// SECTIONS {
+  ///   .data :  { *(EXCLUDE_FILE (*crtend.o *otherfile.o) .ctors) }
+  ///                ^~~~> parseExcludeFile()
+  /// }
+  ///
+  ErrorOr<InputSectionsCmd::VectorTy> parseExcludeFile();
+
+  /// Helper to parse SORT_BY_NAME(, SORT_BY_ALIGNMENT( and SORT_NONE(,
+  /// possibly nested. Returns the number of Token::r_paren tokens that need
+  /// to be consumed, while sortMode is updated with the parsed sort
+  /// criteria.
+  /// Example:
+  ///
+  /// SORT_BY_NAME(SORT_BY_ALIGNMENT(*))
+  /// ^~~~ parseSortDirectives()  ~~^
+  /// Returns 2, finishes with sortMode = WildcardSortMode::ByNameAndAlignment
+  ///
+  int parseSortDirectives(WildcardSortMode &sortMode);
+
+  /// Parse a group of input section names that are sorted via SORT* directives.
+  /// Example:
+  ///   SORT_BY_NAME(SORT_BY_ALIGNMENT(*data *bss))
+  const InputSection *parseSortedInputSections();
+
+  /// Parse input section description statements.
+  /// Example:
+  ///
+  /// SECTIONS {
+  ///   .mysection : crt.o(.data* .bss SORT_BY_NAME(name*))
+  ///                ^~~~ parseInputSectionsCmd()
+  /// }
+  const InputSectionsCmd *parseInputSectionsCmd();
+
+  /// Parse output section description statements.
+  /// Example:
+  ///
+  /// SECTIONS {
+  ///   .data : { crt.o(.data* .bss SORT_BY_NAME(name*)) }
+  ///   ^~~~ parseOutputSectionDescription()
+  /// }
+  const OutputSectionDescription *parseOutputSectionDescription();
+
+  /// Stub for parsing overlay commands. Currently unimplemented.
+  const Overlay *parseOverlay();
+
+  /// Parse the SECTIONS linker script command.
+  /// Example:
+  ///
+  ///   SECTIONS {
+  ///   ^~~~ parseSections()
+  ///     . = 0x100000;
+  ///     .data : { *(.data) }
+  ///   }
+  ///
+  Sections *parseSections();
+
 private:
+  // Owns the entire linker script AST nodes
   llvm::BumpPtrAllocator _alloc;
+
+  // The top-level/entry-point linker script AST node
   LinkerScript _script;
+
   Lexer &_lex;
+
+  // Current token being analyzed
   Token _tok;
+
+  // Annotate whether we buffered the next token to allow peeking
+  bool _peekAvailable;
+  Token _bufferedToken;
 };
 } // end namespace script
 } // end namespace lld
 
 #endif

lib/ReaderWriter/LinkerScript.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lld/ReaderWriter/LinkerScript.h"
 
 namespace lld {
 namespace script {
 void Token::dump(raw_ostream &os) const {
   switch (_kind) {
-#define CASE(name)                              \
-  case Token::name:                             \
-    os << #name ": ";                           \
+#define CASE(name)                                                             \
+  case Token::name:                                                            \
+    os << #name ": ";                                                          \
     break;
+    CASE(unknown)
     CASE(eof)
+    CASE(exclaim)
+    CASE(exclaimequal)
+    CASE(amp)
+    CASE(ampequal)
+    CASE(l_paren)
+    CASE(r_paren)
+    CASE(star)
+    CASE(starequal)
+    CASE(plus)
+    CASE(plusequal)
+    CASE(comma)
+    CASE(minus)
+    CASE(minusequal)
+    CASE(slash)
+    CASE(slashequal)
+    CASE(number)
+    CASE(colon)
+    CASE(semicolon)
+    CASE(less)
+    CASE(lessequal)
+    CASE(lessless)
+    CASE(lesslessequal)
+    CASE(equal)
+    CASE(equalequal)
+    CASE(greater)
+    CASE(greaterequal)
+    CASE(greatergreater)
+    CASE(greatergreaterequal)
+    CASE(question)
     CASE(identifier)
     CASE(libname)
+    CASE(kw_align)
+    CASE(kw_align_with_input)
     CASE(kw_as_needed)
+    CASE(kw_at)
+    CASE(kw_discard)
     CASE(kw_entry)
+    CASE(kw_exclude_file)
     CASE(kw_group)
-  CASE(kw_output_format)
+    CASE(kw_hidden)
+    CASE(kw_keep)
+    CASE(kw_provide)
+    CASE(kw_provide_hidden)
+    CASE(kw_only_if_ro)
+    CASE(kw_only_if_rw)
     CASE(kw_output_arch)
-  CASE(comma)
-  CASE(l_paren)
-  CASE(r_paren)
-  CASE(unknown)
+    CASE(kw_output_format)
+    CASE(kw_overlay)
+    CASE(kw_search_dir)
+    CASE(kw_sections)
+    CASE(kw_sort_by_alignment)
+    CASE(kw_sort_by_init_priority)
+    CASE(kw_sort_by_name)
+    CASE(kw_sort_none)
+    CASE(kw_subalign)
+    CASE(l_brace)
+    CASE(pipe)
+    CASE(pipeequal)
+    CASE(r_brace)
+    CASE(tilde)
 #undef CASE
   }
   os << _range << "\n";
 }
 
+static llvm::ErrorOr<uint64_t> parseDecimal(StringRef str) {
+  uint64_t res = 0;
+  for (auto &c : str) {
+    res *= 10;
+    if (c < '0' || c > '9')
+      return std::errc::io_error;
+    res += c - '0';
+  }
+  return res;
+}
+
+static llvm::ErrorOr<uint64_t> parseOctal(StringRef str) {
+  uint64_t res = 0;
+  for (auto &c : str) {
+    res <<= 3;
+    if (c < '0' || c > '7')
+      return std::errc::io_error;
+    res += c - '0';
+  }
+  return res;
+}
+
+static llvm::ErrorOr<uint64_t> parseBinary(StringRef str) {
+  uint64_t res = 0;
+  for (auto &c : str) {
+    res <<= 1;
+    if (c != '0' && c != '1')
+      return std::errc::io_error;
+    res += c - '0';
+  }
+  return res;
+}
+
+static llvm::ErrorOr<uint64_t> parseHex(StringRef str) {
+  uint64_t res = 0;
+  for (auto &c : str) {
+    res <<= 4;
+    if (c >= '0' && c <= '9')
+      res += c - '0';
+    else if (c >= 'a' && c <= 'f')
+      res += c - 'a' + 10;
+    else if (c >= 'A' && c <= 'F')
+      res += c - 'A' + 10;
+    else
+      return std::errc::io_error;
+  }
+  return res;
+}
+
+static bool parseHexToByteStream(StringRef str, std::string &buf) {
+  unsigned char byte = 0;
+  bool dumpByte = str.size() % 2;
+  for (auto &c : str) {
+    byte <<= 4;
+    if (c >= '0' && c <= '9')
+      byte += c - '0';
+    else if (c >= 'a' && c <= 'f')
+      byte += c - 'a' + 10;
+    else if (c >= 'A' && c <= 'F')
+      byte += c - 'A' + 10;
+    else
+      return false;
+    if (!dumpByte) {
+      dumpByte = true;
+      continue;
+    }
+    buf.push_back(byte);
+    byte = 0;
+    dumpByte = false;
+  }
+  return !dumpByte;
+}
+
+static void dumpByteStream(raw_ostream &os, StringRef stream) {
+  os << "0x";
+  for (auto &c : stream) {
+    unsigned char firstNibble = c >> 4 & 0xF;
+    if (firstNibble > 9)
+      os << (char) ('A' + firstNibble - 10);
+    else
+      os << (char) ('0' + firstNibble);
+    unsigned char secondNibble = c & 0xF;
+    if (secondNibble > 9)
+      os << (char) ('A' + secondNibble - 10);
+    else
+      os << (char) ('0' + secondNibble);
+  }
+}
+
+static llvm::ErrorOr<uint64_t> parseNum(StringRef str) {
+  unsigned multiplier = 1;
+  enum NumKind { decimal, hex, octal, binary };
+  NumKind kind = llvm::StringSwitch<NumKind>(str)
+                     .StartsWith("0x", hex)
+                     .StartsWith("0X", hex)
+                     .StartsWith("0", octal)
+                     .Default(decimal);
+
+  // Parse scale
+  if (str.endswith("K")) {
+    multiplier = 1 << 10;
+    str = str.drop_back();
+  } else if (str.endswith("M")) {
+    multiplier = 1 << 20;
+    str = str.drop_back();
+  }
+
+  // Parse type
+  if (str.endswith_lower("o")) {
+    kind = octal;
+    str = str.drop_back();
+  } else if (str.endswith_lower("h")) {
+    kind = hex;
+    str = str.drop_back();
+  } else if (str.endswith_lower("d")) {
+    kind = decimal;
+    str = str.drop_back();
+  } else if (str.endswith_lower("b")) {
+    kind = binary;
+    str = str.drop_back();
+  }
+
+  llvm::ErrorOr<uint64_t> res(0);
+  switch (kind) {
+  case hex:
+    if (str.startswith_lower("0x"))
+      str = str.drop_front(2);
+    res = parseHex(str);
+    break;
+  case octal:
+    res = parseOctal(str);
+    break;
+  case decimal:
+    res = parseDecimal(str);
+    break;
+  case binary:
+    res = parseBinary(str);
+    break;
+  }
+  if (res.getError())
+    return res;
+
+  *res = *res * multiplier;
+  return res;
+}
+
+bool Lexer::canStartNumber(char c) const {
+  return '0' <= c && c <= '9';
+}
+
+bool Lexer::canContinueNumber(char c) const {
+  switch (c) {
+  // Digits
+  case '0': case '1': case '2': case '3': case '4': case '5': case '6':
+  case '7': case '8': case '9':
+  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+  // Hex marker
+  case 'x': case 'X':
+  // Type suffix
+  case 'h': case 'H': case 'o': case 'O':
+  // Scale suffix
+  case 'M': case 'K':
+    return true;
+  default:
+    return false;
+  }
+}
+
 bool Lexer::canStartName(char c) const {
   switch (c) {
   case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
   case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
   case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
   case 'V': case 'W': case 'X': case 'Y': case 'Z':
   case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
   case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
   case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
   case 'v': case 'w': case 'x': case 'y': case 'z':
   case '_': case '.': case '$': case '/': case '\\':
+  case '*':
     return true;
   default:
     return false;
   }
 }
 
 bool Lexer::canContinueName(char c) const {
   switch (c) {
bool Lexer::canContinueName(char c) const {
   case '-':
   case ':':
     return true;
   default:
     return false;
   }
 }
 
+/// Helper function to split a StringRef in two at the nth character.
+/// The StringRef s is updated, while the function returns the n first
+/// characters.
+static StringRef drop(StringRef &s, int n) {
+  StringRef res = s.substr(0, n);
+  s = s.drop_front(n);
+  return res;
+}
+
 void Lexer::lex(Token &tok) {
   skipWhitespace();
   if (_buffer.empty()) {
     tok = Token(_buffer, Token::eof);
     return;
   }
   switch (_buffer[0]) {
   case 0:
-    tok = Token(_buffer.substr(0, 1), Token::eof);
-    _buffer = _buffer.drop_front();
+    tok = Token(drop(_buffer, 1), Token::eof);
     return;
   case '(':
-    tok = Token(_buffer.substr(0, 1), Token::l_paren);
-    _buffer = _buffer.drop_front();
+    tok = Token(drop(_buffer, 1), Token::l_paren);
     return;
   case ')':
-    tok = Token(_buffer.substr(0, 1), Token::r_paren);
-    _buffer = _buffer.drop_front();
+    tok = Token(drop(_buffer, 1), Token::r_paren);
+    return;
+  case '{':
+    tok = Token(drop(_buffer, 1), Token::l_brace);
+    return;
+  case '}':
+    tok = Token(drop(_buffer, 1), Token::r_brace);
+    return;
+  case '=':
+    if (_buffer.startswith("==")) {
+      tok = Token(drop(_buffer, 2), Token::equalequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::equal);
+    return;
+  case '!':
+    if (_buffer.startswith("!=")) {
+      tok = Token(drop(_buffer, 2), Token::exclaimequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::exclaim);
     return;
   case ',':
-    tok = Token(_buffer.substr(0, 1), Token::comma);
-    _buffer = _buffer.drop_front();
+    tok = Token(drop(_buffer, 1), Token::comma);
     return;
-  default:
-    // Handle quoted strings. They are treated as identifiers for
-    // simplicity.
-    if ((_buffer[0] == '\"') || (_buffer[0] == '\'')) {
-      char c = _buffer[0];
-      _buffer = _buffer.drop_front();
-      auto quotedStringEnd = _buffer.find(c);
-      if (quotedStringEnd == StringRef::npos || quotedStringEnd == 0)
-        break;
-      StringRef word = _buffer.substr(0, quotedStringEnd);
-      tok = Token(word, Token::identifier);
-      _buffer = _buffer.drop_front(quotedStringEnd + 1);
+  case ';':
+    tok = Token(drop(_buffer, 1), Token::semicolon);
+    return;
+  case ':':
+    tok = Token(drop(_buffer, 1), Token::colon);
+    return;
+  case '&':
+    if (_buffer.startswith("&=")) {
+      tok = Token(drop(_buffer, 2), Token::ampequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::amp);
+    return;
+  case '|':
+    if (_buffer.startswith("|=")) {
+      tok = Token(drop(_buffer, 2), Token::pipeequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::pipe);
+    return;
+  case '+':
+    if (_buffer.startswith("+=")) {
+      tok = Token(drop(_buffer, 2), Token::plusequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::plus);
+    return;
+  case '-': {
+    if (_buffer.startswith("-=")) {
+      tok = Token(drop(_buffer, 2), Token::minusequal);
+      return;
+    }
+    if (!_buffer.startswith("-l")) {
+      tok = Token(drop(_buffer, 1), Token::minus);
       return;
     }
     // -l<lib name>
-    if (_buffer.startswith("-l")) {
-      _buffer = _buffer.drop_front(2);
-      StringRef::size_type start = 0;
-      if (_buffer[start] == ':')
-        ++start;
-      if (!canStartName(_buffer[start]))
-        // Create 'unknown' token.
-        break;
-      auto libNameEnd =
-          std::find_if(_buffer.begin() + start + 1, _buffer.end(),
+    auto libNameEnd = std::find_if(_buffer.begin() + start + 1, _buffer.end(),
                                    [=](char c) { return !canContinueName(c); });
-      StringRef::size_type libNameLen =
-          std::distance(_buffer.begin(), libNameEnd);
-      tok = Token(_buffer.substr(0, libNameLen), Token::libname);
-      _buffer = _buffer.drop_front(libNameLen);
-      return;
-    }
-    /// keyword or identifer.
-    if (!canStartName(_buffer[0]))
+  case '<':
+    if (_buffer.startswith("<<=")) {
+      tok = Token(drop(_buffer, 3), Token::lesslessequal);
+      return;
+    }
+    if (_buffer.startswith("<<")) {
+      tok = Token(drop(_buffer, 2), Token::lessless);
+      return;
+    }
+    if (_buffer.startswith("<=")) {
+      tok = Token(drop(_buffer, 2), Token::lessequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::less);
+    return;
+  case '>':
+    if (_buffer.startswith(">>=")) {
+      tok = Token(drop(_buffer, 3), Token::greatergreaterequal);
+      return;
+    }
+    if (_buffer.startswith(">>")) {
+      tok = Token(drop(_buffer, 2), Token::greatergreater);
+      return;
+    }
+    if (_buffer.startswith(">=")) {
+      tok = Token(drop(_buffer, 2), Token::greaterequal);
+      return;
+    }
+    tok = Token(drop(_buffer, 1), Token::greater);
+    return;
+  case '~':
+    tok = Token(drop(_buffer, 1), Token::tilde);
+    return;
+  case '\"': case '\'': {
+    // Handle quoted strings. They are treated as identifiers for
+    // simplicity.
+    char c = _buffer[0];
+    _buffer = _buffer.drop_front();
+    auto quotedStringEnd = _buffer.find(c);
+    if (quotedStringEnd == StringRef::npos || quotedStringEnd == 0)
       break;
-    auto endIter =
-        std::find_if(_buffer.begin() + 1, _buffer.end(), [=](char c) {
-      return !canContinueName(c);
+    StringRef word = _buffer.substr(0, quotedStringEnd);
+    tok = Token(word, Token::identifier);
+    _buffer = _buffer.drop_front(quotedStringEnd + 1);
+    return;
+  }
+  default:
+    // Handle literal numbers
+    if (canStartNumber(_buffer[0])) {
+      auto endIter = std::find_if(_buffer.begin(), _buffer.end(), [=](char c) {
+        return !canContinueNumber(c);
       });
-    StringRef::size_type end =
-        endIter == _buffer.end() ? StringRef::npos
+      StringRef::size_type end = endIter == _buffer.end()
+                                     ? StringRef::npos
                                      : std::distance(_buffer.begin(), endIter);
       if (end == StringRef::npos || end == 0)
         break;
       StringRef word = _buffer.substr(0, end);
-    Token::Kind kind = llvm::StringSwitch<Token::Kind>(word)
-                           .Case("OUTPUT_FORMAT", Token::kw_output_format)
-                           .Case("OUTPUT_ARCH", Token::kw_output_arch)
-                           .Case("GROUP", Token::kw_group)
-                           .Case("AS_NEEDED", Token::kw_as_needed)
-                           .Case("ENTRY", Token::kw_entry)
-                           .Default(Token::identifier);
+      tok = Token(word, Token::number);
+      _buffer = _buffer.drop_front(end);
+      return;
+    }
+    // Handle slashes '/', which can be either an operator inside an expression
+    // or the beginning of an identifier
+    if (_buffer.startswith("/=")) {
+      tok = Token(drop(_buffer, 2), Token::slashequal);
+      return;
+    }
+    if (_buffer[0] == '/' && _buffer.size() > 1 &&
+        !canContinueName(_buffer[1])) {
+      tok = Token(drop(_buffer, 1), Token::slash);
+      return;
+    }
+    // Handle stars '*'
+    if (_buffer.startswith("*=")) {
+      tok = Token(drop(_buffer, 2), Token::starequal);
+      return;
+    }
+    if (_buffer[0] == '*' && _buffer.size() > 1 &&
+        !canContinueName(_buffer[1])) {
+      tok = Token(drop(_buffer, 1), Token::star);
+      return;
+    }
+    // Handle questions '?'
+    if (_buffer[0] == '?' && _buffer.size() > 1 &&
+        !canContinueName(_buffer[1])) {
+      tok = Token(drop(_buffer, 1), Token::question);
+      return;
+    }
+    // keyword or identifier.
+    if (!canStartName(_buffer[0]))
+      break;
+    auto endIter = std::find_if(_buffer.begin() + 1, _buffer.end(),
+                                [=](char c) { return !canContinueName(c); });
+    StringRef::size_type end = endIter == _buffer.end()
+                                   ? StringRef::npos
+                                   : std::distance(_buffer.begin(), endIter);
+    if (end == StringRef::npos || end == 0)
+      break;
+    StringRef word = _buffer.substr(0, end);
+    Token::Kind kind =
+        llvm::StringSwitch<Token::Kind>(word)
+            .Case("ALIGN", Token::kw_align)
+            .Case("ALIGN_WITH_INPUT", Token::kw_align_with_input)
+            .Case("AT", Token::kw_at)
+            .Case("EXCLUDE_FILE", Token::kw_exclude_file)
+            .Case("GROUP", Token::kw_group)
+            .Case("HIDDEN", Token::kw_hidden)
+            .Case("KEEP", Token::kw_keep)
+            .Case("ONLY_IF_RO", Token::kw_only_if_ro)
+            .Case("ONLY_IF_RW", Token::kw_only_if_rw)
+            .Case("OUTPUT_ARCH", Token::kw_output_arch)
+            .Case("OUTPUT_FORMAT", Token::kw_output_format)
+            .Case("OVERLAY", Token::kw_overlay)
+            .Case("PROVIDE", Token::kw_provide)
+            .Case("PROVIDE_HIDDEN", Token::kw_provide_hidden)
+            .Case("SEARCH_DIR", Token::kw_search_dir)
+            .Case("SECTIONS", Token::kw_sections)
+            .Case("SORT", Token::kw_sort_by_name)
+            .Case("SORT_BY_ALIGNMENT", Token::kw_sort_by_alignment)
+            .Case("SORT_BY_INIT_PRIORITY", Token::kw_sort_by_init_priority)
+            .Case("SORT_BY_NAME", Token::kw_sort_by_name)
+            .Case("SORT_NONE", Token::kw_sort_none)
+            .Case("SUBALIGN", Token::kw_subalign)
+            .Case("/DISCARD/", Token::kw_discard)
     tok = Token(word, kind);
     _buffer = _buffer.drop_front(end);
     return;
   }
-  tok = Token(_buffer.substr(0, 1), Token::unknown);
-  _buffer = _buffer.drop_front();
+  tok = Token(drop(_buffer, 1), Token::unknown);
 }
 
 void Lexer::skipWhitespace() {
   while (true) {
     if (_buffer.empty())
       return;
     switch (_buffer[0]) {
     case ' ':
case '/':
         return;
       break;
     default:
       return;
     }
   }
 }
 
+// Constant functions
+void Constant::dump(raw_ostream &os) const { os << _num; }
+
+// Symbol functions
+void Symbol::dump(raw_ostream &os) const { os << _name; }
+
+// FunctionCall functions
+void FunctionCall::dump(raw_ostream &os) const {
+  os << _name << "(";
+  if (unsigned e = _args.size()) {
+    _args[0]->dump(os);
+    for (unsigned i = 1; i != e; ++i) {
+      os << ", ";
+      _args[i]->dump(os);
+    }
+  }
+  os << ")";
+}
+
+// Unary functions
+void Unary::dump(raw_ostream &os) const {
+  os << "(";
+  if (_op == Unary::Minus)
+    os << "-";
+  else
+    os << "~";
+  _child->dump(os);
+  os << ")";
+}
+
+// BinOp functions
+void BinOp::dump(raw_ostream &os) const {
+  os << "(";
+  _lhs->dump(os);
+  os << " ";
+  switch (_op) {
+  case Sum:
+    os << "+";
+    break;
+  case Sub:
+    os << "-";
+    break;
+  case Mul:
+    os << "*";
+    break;
+  case Div:
+    os << "/";
+    break;
+  case Shl:
+    os << "<<";
+    break;
+  case Shr:
+    os << ">>";
+    break;
+  case And:
+    os << "&";
+    break;
+  case Or:
+    os << "|";
+    break;
+  case CompareEqual:
+    os << "==";
+    break;
+  case CompareDifferent:
+    os << "!=";
+    break;
+  case CompareLess:
+    os << "<";
+    break;
+  case CompareGreater:
+    os << ">";
+    break;
+  case CompareLessEqual:
+    os << "<=";
+    break;
+  case CompareGreaterEqual:
+    os << ">=";
+    break;
+  }
+  os << " ";
+  _rhs->dump(os);
+  os << ")";
+}
+
+// TernaryConditional functions
+void TernaryConditional::dump(raw_ostream &os) const {
+  _conditional->dump(os);
+  os << " ? ";
+  _trueExpr->dump(os);
+  os << " : ";
+  _falseExpr->dump(os);
+}
+
+// SymbolAssignment functions
+void SymbolAssignment::dump(raw_ostream &os) const {
+  int numParen = 0;
+
+  if (_assignmentVisibility != Normal) {
+    switch (_assignmentVisibility) {
+    case Hidden:
+      os << "HIDDEN(";
+      break;
+    case Provide:
+      os << "PROVIDE(";
+      break;
+    case ProvideHidden:
+      os << "PROVIDE_HIDDEN(";
+      break;
+    default:
+      llvm_unreachable("Unknown visibility");
+    }
+    ++numParen;
+  }
+
+  os << _symbol << " ";
+  switch (_assignmentKind) {
+  case Simple:
+    os << "=";
+    break;
+  case Sum:
+    os << "+=";
+    break;
+  case Sub:
+    os << "-=";
+    break;
+  case Mul:
+    os << "*=";
+    break;
+  case Div:
+    os << "/=";
+    break;
+  case Shl:
+    os << "<<=";
+    break;
+  case Shr:
+    os << ">>=";
+    break;
+  case And:
+    os << "&=";
+    break;
+  case Or:
+    os << "|=";
+    break;
+  }
+
+  os << " ";
+  _expression->dump(os);
+  if (numParen)
+    os << ")";
+  os << ";";
+}
+
+static int dumpSortDirectives(raw_ostream &os, WildcardSortMode sortMode) {
+  switch (sortMode) {
+  case WildcardSortMode::NA:
+    return 0;
+  case WildcardSortMode::ByName:
+    os << "SORT_BY_NAME(";
+    return 1;
+  case WildcardSortMode::ByAlignment:
+    os << "SORT_BY_ALIGNMENT(";
+    return 1;
+  case WildcardSortMode::ByInitPriority:
+    os << "SORT_BY_INIT_PRIORITY(";
+    return 1;
+  case WildcardSortMode::ByNameAndAlignment:
+    os << "SORT_BY_NAME(SORT_BY_ALIGNMENT(";
+    return 2;
+  case WildcardSortMode::ByAlignmentAndName:
+    os << "SORT_BY_ALIGNMENT(SORT_BY_NAME(";
+    return 2;
+  case WildcardSortMode::None:
+    os << "SORT_NONE(";
+    return 1;
+  }
+}
+
+// InputSectionName functions
+void InputSectionName::dump(raw_ostream &os) const {
+  os << _name;
+}
+
+// InputSectionSortedGroup functions
+static void dumpInputSections(raw_ostream &os,
+                              const std::vector<const InputSection *> &secs) {
+  bool excludeFile = false;
+  bool first = true;
+
+  for (auto &secName : secs) {
+    if (!first)
+      os << " ";
+    first = false;
+    // Coalesce multiple input sections marked with EXCLUDE_FILE in the same
+    // EXCLUDE_FILE() group
+    if (auto inputSec = dyn_cast<InputSectionName>(secName)) {
+      if (!excludeFile && inputSec->hasExcludeFile()) {
+        excludeFile = true;
+        os << "EXCLUDE_FILE(";
+      } else if (excludeFile && !inputSec->hasExcludeFile()) {
+        excludeFile = false;
+        os << ") ";
+      }
+    }
+    secName->dump(os);
+  }
+
+  if (excludeFile)
+    os << ")";
+}
+
+void InputSectionSortedGroup::dump(raw_ostream &os) const {
+  int numParen = dumpSortDirectives(os, _sortMode);
+  dumpInputSections(os, _sections);
+  for (int i = 0; i < numParen; ++i)
+    os << ")";
+}
+
+// InputSectionsCmd functions
+void InputSectionsCmd::dump(raw_ostream &os) const {
+  if (_keep)
+    os << "KEEP(";
+
+  int numParen = dumpSortDirectives(os, _fileSortMode);
+  os << _fileName;
+  for (int i = 0; i < numParen; ++i)
+    os << ")";
+
+  if (_archiveName.size() > 0) {
+    os << ":";
+    numParen = dumpSortDirectives(os, _archiveSortMode);
+    os << _archiveName;
+    for (int i = 0; i < numParen; ++i)
+      os << ")";
+  }
+
+  if (_sections.size() > 0) {
+    os << "(";
+    dumpInputSections(os, _sections);
+    os << ")";
+  }
+
+  if (_keep)
+    os << ")";
+}
+
+// OutputSectionDescription functions
+void OutputSectionDescription::dump(raw_ostream &os) const {
+  if (_discard)
+    os << "/DISCARD/";
+  else
+    os << _sectionName;
+
+  if (_address) {
+    os << " ";
+    _address->dump(os);
+  }
+  os << " :\n";
+
+  if (_at) {
+    os << "  AT(";
+    _at->dump(os);
+    os << ")\n";
+  }
+
+  if (_align) {
+    os << "  ALIGN(";
+    _align->dump(os);
+    os << ")\n";
+  } else if (_alignWithInput) {
+    os << " ALIGN_WITH_INPUT\n";
+  }
+
+  if (_subAlign) {
+    os << "  SUBALIGN(";
+    _subAlign->dump(os);
+    os << ")\n";
+  }
+
+  switch (_constraint) {
+  case C_None:
+    break;
+  case C_OnlyIfRO:
+    os << "ONLY_IF_RO";
+    break;
+  case C_OnlyIfRW:
+    os << "ONLY_IF_RW";
+    break;
+  }
+
+  os << "  {\n";
+  for (auto &command : _outputSectionCommands) {
+    os << "    ";
+    command->dump(os);
+    os << "\n";
+  }
+  os << "  }";
+
+  if (_fillStream.size() > 0) {
+    os << " =";
+    dumpByteStream(os, _fillStream);
+  } else if (_fillExpr) {
+    os << " =";
+    _fillExpr->dump(os);
+  }
+}
+
+// Sections functions
+void Sections::dump(raw_ostream &os) const {
+  os << "SECTIONS\n{\n";
+  for (auto &command : _sectionsCommands) {
+    command->dump(os);
+    os << "\n";
+  }
+  os << "}\n";
+}
+
+// Parser functions
 LinkerScript *Parser::parse() {
   // Get the first token.
   _lex.lex(_tok);
   // Parse top level commands.
   while (true) {
     switch (_tok._kind) {
     case Token::eof:
       return &_script;
+    case Token::semicolon:
+      consumeToken();
+      break;
     case Token::kw_output_format: {
       auto outputFormat = parseOutputFormat();
       if (!outputFormat)
         return nullptr;
       _script._commands.push_back(outputFormat);
       break;
     }
     case Token::kw_output_arch: {
       auto outputArch = parseOutputArch();
       if (!outputArch)
         return nullptr;
       _script._commands.push_back(outputArch);
       break;
     }
     case Token::kw_group: {
       auto group = parseGroup();
       if (!group)
         return nullptr;
       _script._commands.push_back(group);
       break;
     }
     case Token::kw_as_needed:
       // Not allowed at top level.
+      error(_tok, "AS_NEEDED not allowed at top level.");
       return nullptr;
     case Token::kw_entry: {
       Entry *entry = parseEntry();
       if (!entry)
         return nullptr;
       _script._commands.push_back(entry);
       break;
     }
+    case Token::kw_search_dir: {
+      SearchDir *searchDir = parseSearchDir();
+      if (!searchDir)
+        return nullptr;
+      _script._commands.push_back(searchDir);
+      break;
+    }
+    case Token::kw_sections: {
+      Sections *sections = parseSections();
+      if (!sections)
+        return nullptr;
+      _script._commands.push_back(sections);
+      break;
+    }
+    case Token::identifier:
+    case Token::kw_hidden:
+    case Token::kw_provide:
+    case Token::kw_provide_hidden: {
+      const Command *cmd = parseSymbolAssignment();
+      if (!cmd)
+        return nullptr;
+      _script._commands.push_back(cmd);
+      break;
+    }
     default:
       // Unexpected.
+      error(_tok, "expected linker script command");
       return nullptr;
     }
   }
 
   return nullptr;
 }
 
+const Expression *Parser::parseFunctionCall() {
+  assert((_tok._kind == Token::identifier || _tok._kind == Token::kw_align) &&
+         "expected function call first tokens");
+  std::vector<const Expression *> params;
+  StringRef name = _tok._range;
+
+  consumeToken();
+  if (!expectAndConsume(Token::l_paren, "expected ("))
+    return nullptr;
+
+  if (_tok._kind == Token::r_paren) {
+    consumeToken();
+    return new (_alloc) FunctionCall(_tok._range, params);
+  }
+
+  if (const Expression *firstParam = parseExpression())
+    params.push_back(firstParam);
+  else
+    return nullptr;
+
+  while (_tok._kind == Token::comma) {
+    consumeToken();
+    if (const Expression *param = parseExpression())
+      params.push_back(param);
+    else
+      return nullptr;
+  }
+
+  if (!expectAndConsume(Token::r_paren, "expected )"))
+    return nullptr;
+  return new (_alloc) FunctionCall(name, params);
+}
+
+bool Parser::expectExprOperand() {
+  if (!(_tok._kind == Token::identifier || _tok._kind == Token::number ||
+        _tok._kind == Token::kw_align || _tok._kind == Token::l_paren ||
+        _tok._kind == Token::minus || _tok._kind == Token::tilde)) {
+    error(_tok, "expected symbol, number, minus, tilde or left parenthesis.");
+    return false;
+  }
+  return true;
+}
+
+const Expression *Parser::parseExprOperand() {
+  if (!expectExprOperand())
+    return nullptr;
+
+  switch (_tok._kind) {
+  case Token::identifier: {
+    if (peek()._kind== Token::l_paren)
+      return parseFunctionCall();
+    Symbol *sym = new (_alloc) Symbol(_tok._range);
+    consumeToken();
+    return sym;
+  }
+  case Token::kw_align:
+    return parseFunctionCall();
+  case Token::minus:
+    consumeToken();
+    return new (_alloc) Unary(Unary::Minus, parseExprOperand());
+  case Token::tilde:
+    consumeToken();
+    return new (_alloc) Unary(Unary::Not, parseExprOperand());
+  case Token::number: {
+    auto val = parseNum(_tok._range);
+    if (val.getError()) {
+      error(_tok, "Unrecognized number constant");
+      return nullptr;
+    }
+    Constant *c = new (_alloc) Constant(*val);
+    consumeToken();
+    return c;
+  }
+  case Token::l_paren: {
+    consumeToken();
+    const Expression *expr = parseExpression();
+    if (!expectAndConsume(Token::r_paren, "expected )"))
+      return nullptr;
+    return expr;
+  }
+  default:
+    llvm_unreachable("Unknown token");
+  }
+}
+
+static bool TokenToBinOp(const Token &tok, BinOp::Operation &op,
+                         unsigned &precedence) {
+  switch (tok._kind) {
+  case Token::star:
+    op = BinOp::Mul;
+    precedence = 3;
+    return true;
+  case Token::slash:
+    op = BinOp::Div;
+    precedence = 3;
+    return true;
+  case Token::plus:
+    op = BinOp::Sum;
+    precedence = 4;
+    return true;
+  case Token::minus:
+    op = BinOp::Sub;
+    precedence = 4;
+    return true;
+  case Token::lessless:
+    op = BinOp::Shl;
+    precedence = 5;
+    return true;
+  case Token::greatergreater:
+    op = BinOp::Shr;
+    precedence = 5;
+    return true;
+  case Token::less:
+    op = BinOp::CompareLess;
+    precedence = 6;
+    return true;
+  case Token::greater:
+    op = BinOp::CompareGreater;
+    precedence = 6;
+    return true;
+  case Token::lessequal:
+    op = BinOp::CompareLessEqual;
+    precedence = 6;
+    return true;
+  case Token::greaterequal:
+    op = BinOp::CompareGreaterEqual;
+    precedence = 6;
+    return true;
+  case Token::equalequal:
+    op = BinOp::CompareEqual;
+    precedence = 7;
+    return true;
+  case Token::exclaimequal:
+    op = BinOp::CompareDifferent;
+    precedence = 7;
+    return true;
+  case Token::amp:
+    op = BinOp::And;
+    precedence = 8;
+    return true;
+  case Token::pipe:
+    op = BinOp::Or;
+    precedence = 10;
+    return true;
+  default:
+    break;
+  }
+  return false;
+}
+
+static bool isExpressionOperator(Token tok) {
+  switch (tok._kind) {
+  case Token::star:
+  case Token::slash:
+  case Token::plus:
+  case Token::minus:
+  case Token::lessless:
+  case Token::greatergreater:
+  case Token::less:
+  case Token::greater:
+  case Token::lessequal:
+  case Token::greaterequal:
+  case Token::equalequal:
+  case Token::exclaimequal:
+  case Token::amp:
+  case Token::pipe:
+  case Token::question:
+    return true;
+  default:
+    return false;
+  }
+}
+
+const Expression *Parser::parseExpression(unsigned precedence) {
+  assert(precedence <= 13 && "Invalid precedence value");
+  if (!expectExprOperand())
+    return nullptr;
+
+  const Expression *expr = parseExprOperand();
+  if (!expr)
+    return nullptr;
+
+  BinOp::Operation op;
+  unsigned binOpPrecedence = 0;
+  if (TokenToBinOp(_tok, op, binOpPrecedence)) {
+    if (precedence >= binOpPrecedence)
+      return parseOperatorOperandLoop(expr, precedence);
+    return expr;
+  }
+
+  // Non-binary operators
+  if (_tok._kind == Token::question && precedence >= 13)
+    return parseOperatorOperandLoop(expr, precedence);
+  return expr;
+}
+
+const Expression *Parser::parseOperatorOperandLoop(const Expression *lhs,
+                                                   unsigned highestPrecedence) {
+  assert(highestPrecedence <= 13 && "Invalid precedence value");
+  unsigned precedence = 0;
+  const Expression *binOp = nullptr;
+
+  while (1) {
+    BinOp::Operation op;
+    if (!TokenToBinOp(_tok, op, precedence)) {
+      if (_tok._kind == Token::question && highestPrecedence >= 13)
+        return parseTernaryCondOp(lhs);
+      return binOp;
+    }
+
+    if (precedence > highestPrecedence)
+      return binOp;
+
+    consumeToken();
+    const Expression *rhs = parseExpression(precedence - 1);
+    if (!rhs)
+      return nullptr;
+    binOp = new (_alloc) BinOp(lhs, op, rhs);
+    lhs = binOp;
+  }
+}
+
+const Expression *Parser::parseTernaryCondOp(const Expression *lhs) {
+  assert(_tok._kind == Token::question && "Expected question mark");
+
+  consumeToken();
+
+  // The ternary conditional operator has right-to-left associativity.
+  // To implement this, we allow our children to contain ternary conditional
+  // operators themselves (precedence 13).
+  const Expression *trueExpr = parseExpression(13);
+  if (!trueExpr)
+    return nullptr;
+
+  if (!expectAndConsume(Token::colon, "expected :"))
+    return nullptr;
+
+  const Expression *falseExpr = parseExpression(13);
+  if (!falseExpr)
+    return nullptr;
+
+  return new (_alloc) TernaryConditional(lhs, trueExpr, falseExpr);
+}
+
 // Parse OUTPUT_FORMAT(ident)
 OutputFormat *Parser::parseOutputFormat() {
   assert(_tok._kind == Token::kw_output_format && "Expected OUTPUT_FORMAT!");
   consumeToken();
   if (!expectAndConsume(Token::l_paren, "expected ("))
     return nullptr;
 
   if (_tok._kind != Token::identifier) {
OutputArch *Parser::parseOutputArch() {
 
   if (_tok._kind != Token::identifier) {
     error(_tok, "Expected identifier in OUTPUT_ARCH.");
     return nullptr;
   }
 
   auto ret = new (_alloc) OutputArch(_tok._range);
   consumeToken();
 
   if (!expectAndConsume(Token::r_paren, "expected )"))
     return nullptr;
 
   return ret;
 }
 
 // Parse GROUP(file ...)
 Group *Parser::parseGroup() {
Entry *Parser::parseEntry() {
   }
   StringRef entryName(_tok._range);
   consumeToken();
   if (!expectAndConsume(Token::r_paren, "expected )"))
     return nullptr;
   return new (_alloc) Entry(entryName);
 }
 
+// Parse SEARCH_DIR(ident)
+SearchDir *Parser::parseSearchDir() {
+  assert(_tok._kind == Token::kw_search_dir && "Expected SEARCH_DIR!");
+  consumeToken();
+  if (!expectAndConsume(Token::l_paren, "expected ("))
+    return nullptr;
+  if (_tok._kind != Token::identifier) {
+    error(_tok, "expected identifier in SEARCH_DIR");
+    return nullptr;
+  }
+  StringRef searchPath(_tok._range);
+  consumeToken();
+  if (!expectAndConsume(Token::r_paren, "expected )"))
+    return nullptr;
+  return new (_alloc) SearchDir(searchPath);
+}
+
+const SymbolAssignment *Parser::parseSymbolAssignment() {
+  assert((_tok._kind == Token::identifier || _tok._kind == Token::kw_hidden ||
+          _tok._kind == Token::kw_provide ||
+          _tok._kind == Token::kw_provide_hidden) &&
+         "Expected identifier!");
+  SymbolAssignment::AssignmentVisibility visibility = SymbolAssignment::Normal;
+  SymbolAssignment::AssignmentKind kind;
+  int numParen = 0;
+
+  switch (_tok._kind) {
+  case Token::kw_hidden:
+    visibility = SymbolAssignment::Hidden;
+    ++numParen;
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return nullptr;
+    break;
+  case Token::kw_provide:
+    visibility = SymbolAssignment::Provide;
+    ++numParen;
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return nullptr;
+    break;
+  case Token::kw_provide_hidden:
+    visibility = SymbolAssignment::ProvideHidden;
+    ++numParen;
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return nullptr;
+    break;
+  default:
+    break;
+  }
+
+  StringRef name = _tok._range;
+  consumeToken();
+
+  // Parse assignment operator (=, +=, -= etc.)
+  switch (_tok._kind) {
+  case Token::equal:
+    kind = SymbolAssignment::Simple;
+    break;
+  case Token::plusequal:
+    kind = SymbolAssignment::Sum;
+    break;
+  case Token::minusequal:
+    kind = SymbolAssignment::Sub;
+    break;
+  case Token::starequal:
+    kind = SymbolAssignment::Mul;
+    break;
+  case Token::slashequal:
+    kind = SymbolAssignment::Div;
+    break;
+  case Token::ampequal:
+    kind = SymbolAssignment::And;
+    break;
+  case Token::pipeequal:
+    kind = SymbolAssignment::Or;
+    break;
+  case Token::lesslessequal:
+    kind = SymbolAssignment::Shl;
+    break;
+  case Token::greatergreaterequal:
+    kind = SymbolAssignment::Shr;
+    break;
+  default:
+    error(_tok, "unexpected token");
+    return nullptr;
+  }
+
+  consumeToken();
+
+  const Expression *expr = nullptr;
+  switch (_tok._kind) {
+  case Token::number:
+  case Token::kw_align:
+  case Token::identifier:
+  case Token::l_paren:
+    expr = parseExpression();
+    if (!expr)
+      return nullptr;
+    break;
+  default:
+    error(_tok, "unexpected token while parsing assignment value.");
+    return nullptr;
+  }
+
+  for (int i = 0; i < numParen; ++i)
+    if (!expectAndConsume(Token::r_paren, "expected )"))
+      return nullptr;
+
+  return new (_alloc) SymbolAssignment(name, expr, kind, visibility);
+}
+
+llvm::ErrorOr<InputSectionsCmd::VectorTy> Parser::parseExcludeFile() {
+  assert(_tok._kind == Token::kw_exclude_file && "Expected EXCLUDE_FILE!");
+  InputSectionsCmd::VectorTy res;
+  consumeToken();
+
+  if (!expectAndConsume(Token::l_paren, "expected ("))
+    return llvm::ErrorOr<InputSectionsCmd::VectorTy>(
+        std::make_error_code(std::errc::io_error));
+
+  while (_tok._kind == Token::identifier) {
+    res.push_back(new (_alloc) InputSectionName(_tok._range, true));
+    consumeToken();
+  }
+
+  if (!expectAndConsume(Token::r_paren, "expected )"))
+    return llvm::ErrorOr<InputSectionsCmd::VectorTy>(
+        std::make_error_code(std::errc::io_error));
+  return llvm::ErrorOr<InputSectionsCmd::VectorTy>(std::move(res));
+}
+
+int Parser::parseSortDirectives(WildcardSortMode &sortMode) {
+  int numParsedDirectives = 0;
+  sortMode = WildcardSortMode::NA;
+
+  if (_tok._kind == Token::kw_sort_by_name) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return -1;
+    ++numParsedDirectives;
+    sortMode = WildcardSortMode::ByName;
+  }
+
+  if (_tok._kind == Token::kw_sort_by_init_priority) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return -1;
+    ++numParsedDirectives;
+    sortMode = WildcardSortMode::ByInitPriority;
+  }
+
+  if (_tok._kind == Token::kw_sort_by_alignment) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return -1;
+    ++numParsedDirectives;
+    if (sortMode != WildcardSortMode::ByName)
+      sortMode = WildcardSortMode::ByAlignment;
+    else
+      sortMode = WildcardSortMode::ByNameAndAlignment;
+  }
+
+  if (numParsedDirectives < 2 && _tok._kind == Token::kw_sort_by_name) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return -1;
+    ++numParsedDirectives;
+    if (sortMode == WildcardSortMode::ByAlignment)
+      sortMode = WildcardSortMode::ByAlignmentAndName;
+  }
+
+  if (numParsedDirectives < 2 && _tok._kind == Token::kw_sort_by_alignment) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return -1;
+    ++numParsedDirectives;
+  }
+
+  if (numParsedDirectives == 0 && _tok._kind == Token::kw_sort_none) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return -1;
+    ++numParsedDirectives;
+    sortMode = WildcardSortMode::None;
+  }
+
+  return numParsedDirectives;
+}
+
+const InputSection *Parser::parseSortedInputSections() {
+  assert((_tok._kind == Token::kw_sort_by_name ||
+          _tok._kind == Token::kw_sort_by_alignment ||
+          _tok._kind == Token::kw_sort_by_init_priority ||
+          _tok._kind == Token::kw_sort_none) &&
+         "Expected SORT directives!");
+
+  WildcardSortMode sortMode = WildcardSortMode::NA;
+  int numParen = parseSortDirectives(sortMode);
+  if (numParen == -1)
+    return nullptr;
+
+  std::vector<const InputSection *> inputSections;
+
+  while (_tok._kind == Token::identifier) {
+    inputSections.push_back(new (_alloc) InputSectionName(_tok._range, false));
+    consumeToken();
+  }
+
+  // Eat "numParen" rparens
+  for (int i = 0, e = numParen; i != e; ++i)
+    if (!expectAndConsume(Token::r_paren, "expected )"))
+      return nullptr;
+
+  return new (_alloc) InputSectionSortedGroup(sortMode, inputSections);
+}
+
+const InputSectionsCmd *Parser::parseInputSectionsCmd() {
+  assert((_tok._kind == Token::identifier || _tok._kind == Token::colon ||
+          _tok._kind == Token::star || _tok._kind == Token::kw_keep ||
+          _tok._kind == Token::kw_sort_by_name ||
+          _tok._kind == Token::kw_sort_by_alignment ||
+          _tok._kind == Token::kw_sort_by_init_priority ||
+          _tok._kind == Token::kw_sort_none) &&
+         "Expected input section first tokens!");
+  int numParen = 1;
+  bool keep = false;
+  WildcardSortMode fileSortMode = WildcardSortMode::NA;
+  WildcardSortMode archiveSortMode = WildcardSortMode::NA;
+  StringRef fileName;
+  StringRef archiveName;
+
+  if (_tok._kind == Token::kw_keep) {
+    consumeToken();
+    if (!expectAndConsume(Token::l_paren, "expected ("))
+      return nullptr;
+    ++numParen;
+    keep = true;
+  }
+
+  // Input name
+  if (_tok._kind != Token::colon) {
+    int numParen = parseSortDirectives(fileSortMode);
+    if (numParen == -1)
+      return nullptr;
+    fileName = _tok._range;
+    consumeToken();
+    if (numParen) {
+      while (numParen--)
+        if (!expectAndConsume(Token::r_paren, "expected )"))
+          return nullptr;
+    }
+  }
+  if (_tok._kind == Token::colon) {
+    consumeToken();
+    if (_tok._kind == Token::identifier ||
+        _tok._kind == Token::kw_sort_by_name ||
+        _tok._kind == Token::kw_sort_by_alignment ||
+        _tok._kind == Token::kw_sort_by_init_priority ||
+        _tok._kind == Token::kw_sort_none) {
+      int numParen = parseSortDirectives(archiveSortMode);
+      if (numParen == -1)
+        return nullptr;
+      archiveName = _tok._range;
+      consumeToken();
+      if (numParen) {
+        while (numParen--)
+          if (!expectAndConsume(Token::r_paren, "expected )"))
+            return nullptr;
+      }
+    }
+  }
+
+  std::vector<const InputSection *> inputSections;
+
+  if (_tok._kind != Token::l_paren)
+    return new (_alloc)
+        InputSectionsCmd(fileName, archiveName, keep, fileSortMode,
+                         archiveSortMode, inputSections);
+  consumeToken();
+
+  while (_tok._kind == Token::identifier ||
+         _tok._kind == Token::kw_exclude_file ||
+         _tok._kind == Token::kw_sort_by_name ||
+         _tok._kind == Token::kw_sort_by_alignment ||
+         _tok._kind == Token::kw_sort_by_init_priority ||
+         _tok._kind == Token::kw_sort_none) {
+    switch (_tok._kind) {
+    case Token::kw_exclude_file: {
+      auto vec = parseExcludeFile();
+      if (vec.getError())
+        return nullptr;
+      inputSections.insert(inputSections.end(), vec->begin(), vec->end());
+      break;
+    }
+    case Token::star:
+    case Token::identifier: {
+      inputSections.push_back(new (_alloc)
+                                  InputSectionName(_tok._range, false));
+      consumeToken();
+      break;
+    }
+    case Token::kw_sort_by_name:
+    case Token::kw_sort_by_alignment:
+    case Token::kw_sort_by_init_priority:
+    case Token::kw_sort_none: {
+      const InputSection *group = parseSortedInputSections();
+      if (!group)
+        return nullptr;
+      inputSections.push_back(group);
+      break;
+    }
+    default:
+      llvm_unreachable("Unknown token");
+    }
+  }
+
+  for (int i = 0; i < numParen; ++i)
+    if (!expectAndConsume(Token::r_paren, "expected )"))
+      return nullptr;
+  return new (_alloc)
+      InputSectionsCmd(fileName, archiveName, keep, fileSortMode,
+                       archiveSortMode, inputSections);
+}
+
+const OutputSectionDescription *Parser::parseOutputSectionDescription() {
+  assert((_tok._kind == Token::kw_discard || _tok._kind == Token::identifier) &&
+         "Expected /DISCARD/ or identifier!");
+  StringRef sectionName;
+  const Expression *address = nullptr;
+  const Expression *align = nullptr;
+  const Expression *subAlign = nullptr;
+  const Expression *at = nullptr;
+  const Expression *fillExpr = nullptr;
+  StringRef fillStream;
+  bool alignWithInput = false;
+  bool discard = false;
+  OutputSectionDescription::Constraint constraint =
+      OutputSectionDescription::C_None;
+  std::vector<const Command *> outputSectionCommands;
+
+  if (_tok._kind == Token::kw_discard)
+    discard = true;
+  else
+    sectionName = _tok._range;
+  consumeToken();
+
+  if (_tok._kind == Token::number || _tok._kind == Token::identifier ||
+      _tok._kind == Token::kw_align || _tok._kind == Token::l_paren) {
+    address = parseExpression();
+    if (!address)
+      return nullptr;
+  }
+
+  if (!expectAndConsume(Token::colon, "expected :"))
+    return nullptr;
+
+  if (_tok._kind == Token::kw_at) {
+    consumeToken();
+    at = parseExpression();
+    if (!at)
+      return nullptr;
+  }
+
+  if (_tok._kind == Token::kw_align) {
+    consumeToken();
+    align = parseExpression();
+    if (!align)
+      return nullptr;
+  }
+
+  if (_tok._kind == Token::kw_align_with_input) {
+    consumeToken();
+    alignWithInput = true;
+  }
+
+  if (_tok._kind == Token::kw_subalign) {
+    consumeToken();
+    subAlign = parseExpression();
+    if (!subAlign)
+      return nullptr;
+  }
+
+  if (_tok._kind == Token::kw_only_if_ro) {
+    consumeToken();
+    constraint = OutputSectionDescription::C_OnlyIfRO;
+  } else if (_tok._kind == Token::kw_only_if_rw) {
+    consumeToken();
+    constraint = OutputSectionDescription::C_OnlyIfRW;
+  }
+
+  if (!expectAndConsume(Token::l_brace, "expected {"))
+    return nullptr;
+
+  // Parse zero or more output-section-commands
+  while (_tok._kind != Token::r_brace) {
+    switch (_tok._kind) {
+    case Token::semicolon:
+      consumeToken();
+      break;
+    case Token::identifier:
+      switch (peek()._kind) {
+      case Token::equal:
+      case Token::plusequal:
+      case Token::minusequal:
+      case Token::starequal:
+      case Token::slashequal:
+      case Token::ampequal:
+      case Token::pipeequal:
+      case Token::lesslessequal:
+      case Token::greatergreaterequal:
+        if (const Command *cmd = parseSymbolAssignment())
+          outputSectionCommands.push_back(cmd);
+        else
+          return nullptr;
+        break;
+      default:
+        if (const Command *cmd = parseInputSectionsCmd())
+          outputSectionCommands.push_back(cmd);
+        else
+          return nullptr;
+        break;
+      }
+      break;
+    case Token::kw_keep:
+    case Token::star:
+    case Token::colon:
+    case Token::kw_sort_by_name:
+    case Token::kw_sort_by_alignment:
+    case Token::kw_sort_by_init_priority:
+    case Token::kw_sort_none:
+      if (const Command *cmd = parseInputSectionsCmd())
+        outputSectionCommands.push_back(cmd);
+      else
+        return nullptr;
+      break;
+    case Token::kw_hidden:
+    case Token::kw_provide:
+    case Token::kw_provide_hidden:
+      if (const Command *cmd = parseSymbolAssignment())
+        outputSectionCommands.push_back(cmd);
+      else
+        return nullptr;
+      break;
+    default:
+      error(_tok, "expected symbol assignment or input file name.");
+      return nullptr;
+    }
+  }
+
+  if (!expectAndConsume(Token::r_brace, "expected }"))
+    return nullptr;
+
+  if (_tok._kind == Token::equal) {
+    consumeToken();
+    if (_tok._kind != Token::number || !_tok._range.startswith_lower("0x")) {
+      fillExpr = parseExpression();
+      if (!fillExpr)
+        return nullptr;
+    } else {
+      std::string strBuf;
+      if (isExpressionOperator(peek()) ||
+          !parseHexToByteStream(_tok._range.drop_front(2), strBuf)) {
+        fillExpr = parseExpression();
+        if(!fillExpr)
+          return nullptr;
+      } else {
+        char *rawBuf = (char *) _alloc.Allocate(strBuf.size(), 1);
+        memcpy(rawBuf, strBuf.c_str(), strBuf.size());
+        fillStream = StringRef(rawBuf, strBuf.size());
+        consumeToken();
+      }
+    }
+  }
+
+  return new (_alloc) OutputSectionDescription(
+      sectionName, address, align, subAlign, at, fillExpr, fillStream,
+      alignWithInput, discard, constraint, outputSectionCommands);
+}
+
+const Overlay *Parser::parseOverlay() {
+  assert(_tok._kind == Token::kw_overlay && "Expected OVERLAY!");
+  error(_tok, "Overlay description is not yet supported.");
+  return nullptr;
+}
+
+Sections *Parser::parseSections() {
+  assert(_tok._kind == Token::kw_sections && "Expected SECTIONS!");
+  consumeToken();
+  if (!expectAndConsume(Token::l_brace, "expected {"))
+    return nullptr;
+  std::vector<const Command *> sectionsCommands;
+
+  bool unrecognizedToken = false;
+  // Parse zero or more sections-commands
+  while (!unrecognizedToken) {
+    switch (_tok._kind) {
+    case Token::semicolon:
+      consumeToken();
+      break;
+
+    case Token::identifier:
+      switch (peek()._kind) {
+      case Token::equal:
+      case Token::plusequal:
+      case Token::minusequal:
+      case Token::starequal:
+      case Token::slashequal:
+      case Token::ampequal:
+      case Token::pipeequal:
+      case Token::lesslessequal:
+      case Token::greatergreaterequal:
+        if (const Command *cmd = parseSymbolAssignment())
+          sectionsCommands.push_back(cmd);
+        else
+          return nullptr;
+        break;
+      default:
+        if (const Command *cmd = parseOutputSectionDescription())
+          sectionsCommands.push_back(cmd);
+        else
+          return nullptr;
+        break;
+      }
+      break;
+
+    case Token::kw_discard:
+    case Token::star:
+      if (const Command *cmd = parseOutputSectionDescription())
+        sectionsCommands.push_back(cmd);
+      else
+        return nullptr;
+      break;
+
+    case Token::kw_entry:
+      if (const Command *cmd = parseEntry())
+        sectionsCommands.push_back(cmd);
+      else
+        return nullptr;
+      break;
+
+    case Token::kw_hidden:
+    case Token::kw_provide:
+    case Token::kw_provide_hidden:
+      if (const Command *cmd = parseSymbolAssignment())
+        sectionsCommands.push_back(cmd);
+      else
+        return nullptr;
+      break;
+
+    case Token::kw_overlay:
+      if (const Command *cmd = parseOverlay())
+        sectionsCommands.push_back(cmd);
+      else
+        return nullptr;
+      break;
+
+    default:
+      unrecognizedToken = true;
+      break;
+    }
+  }
+
+  if (!expectAndConsume(
+          Token::r_brace,
+          "expected symbol assignment, entry, overlay or output section name."))
+    return nullptr;
+
+  return new (_alloc) Sections(sectionsCommands);
+}
+
 } // end namespace script
 } // end namespace lld

test/LinkerScript/expr-precedence.test

+/*
+  RUN: linker-script-test %s | FileCheck %s
+*/
+SECTIONS {
+    . = foo >= bar + 1 ? bar : 1- - - -1;
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: foo
+CHECK: greaterequal: >=
+CHECK: identifier: bar
+CHECK: plus: +
+CHECK: number: 1
+CHECK: question: ?
+CHECK: identifier: bar
+CHECK: colon: :
+CHECK: number: 1
+CHECK: minus: -
+CHECK: minus: -
+CHECK: minus: -
+CHECK: minus: -
+CHECK: number: 1
+CHECK: semicolon: ;
+CHECK: r_brace: }
+CHECK: eof:
+CHECK: SECTIONS
+CHECK: {
+CHECK: . = (foo >= (bar + 1)) ? bar : (1 - (-(-(-1))))
+CHECK: }
+*/

test/LinkerScript/incomplete-ternary.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -input-file %t -check-prefix=CHECK-ERR %s
+*/
+SECTIONS {
+    . = foo ? bar;
+/*
+CHECK-ERR: [[@LINE-2]]:18: error: expected :
+CHECK-ERR-NEXT: {{^    \. = foo \? bar;}}
+CHECK-ERR-NEXT: {{^                 \^}}
+*/
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: foo
+CHECK: question: ?
+CHECK: identifier: bar
+CHECK: semicolon: ;
+CHECK: r_brace: }
+CHECK: eof:
+*/

test/LinkerScript/linker-script-outputformat.test

 /* RUN: linker-script-test %s | FileCheck %s
 */
 
 OUTPUT_FORMAT(elf64-x86-64)
 
 /*
 CHECK: kw_output_format: OUTPUT_FORMAT
 CHECK: l_paren: (
 CHECK: identifier: elf64-x86-64
 CHECK: r_paren: )
-CHECK: OUTPUT_FORMAT(elf64-x86-64)
+CHECK: OUTPUT_FORMAT("elf64-x86-64")
 */

test/LinkerScript/linker-script.test

 CHECK: libname: m
 CHECK: libname: :libgcc.a
 CHECK: r_paren: )
 CHECK: kw_entry: ENTRY
 CHECK: l_paren: (
 CHECK: identifier: init
 CHECK: r_paren: )
 CHECK: eof:
-CHECK: OUTPUT_FORMAT(elf64-x86-64,elf64-x86-64,elf64-x86-64)
+CHECK: OUTPUT_FORMAT("elf64-x86-64","elf64-x86-64","elf64-x86-64")
 CHECK: GROUP(/lib/x86_64-linux-gnu/libc.so.6 /usr/lib/x86_64-linux-gnu/libc_nonshared.a AS_NEEDED(/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2) -lm -l:libgcc.a)
 CHECK: ENTRY(init)
 */

test/LinkerScript/missing-entry-symbol.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -input-file %t -check-prefix=CHECK-ERR %s
+*/
+SECTIONS {
+    ENTRY()
+/*
+CHECK-ERR: [[@LINE-2]]:11: error: expected identifier in ENTRY
+CHECK-ERR-NEXT: {{^    ENTRY()}}
+CHECK-ERR-NEXT: {{^          \^}}
+*/
+}
+
+/*
+CHECK: l_brace: {
+CHECK: kw_entry: ENTRY
+CHECK: l_paren: (
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: eof:
+*/

test/LinkerScript/missing-input-file-name.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -input-file %t -check-prefix=CHECK-ERR %s
+*/
+SECTIONS {
+    .text : { ()}
+/*
+CHECK-ERR: [[@LINE-2]]:15: error: expected symbol assignment or input file name.
+CHECK-ERR-NEXT: {{^    \.text : { \(\)}}}
+CHECK-ERR-NEXT: {{^              \^}}
+*/
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: identifier: .text
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: l_paren: (
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: r_brace: }
+CHECK: eof:
+*/

test/LinkerScript/missing-input-sections.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -input-file %t -check-prefix=CHECK-ERR %s
+*/
+SECTIONS {
+   .text : { *(+)}
+/*
+CHECK-ERR: [[@LINE-2]]:16: error: expected )
+CHECK-ERR-NEXT: {{^   \.text : { \*\(\+\)}}}
+CHECK-ERR-NEXT: {{^                 \^}}
+*/
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: identifier: .text
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: plus: +
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: r_brace: }
+CHECK: eof:
+*/

test/LinkerScript/missing-operand.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -check-prefix=CHECK-ERR -input-file %t %s
+*/
+SECTIONS {
+    . = foo / ;
+/*
+CHECK-ERR: [[@LINE-2]]:15: error: expected symbol, number, minus, tilde or left parenthesis.
+CHECK-ERR-NEXT: {{^ . = foo / ;}}
+CHECK-ERR-NEXT: {{^           \^}}
+*/
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: foo
+CHECK: slash: /
+CHECK: semicolon: ;
+CHECK: r_brace: }
+CHECK: eof:
+ */

test/LinkerScript/missing-output-section-name.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -input-file %t -check-prefix=CHECK-ERR %s
+*/
+SECTIONS {
+    : { *()}
+/*
+CHECK-ERR: [[@LINE-2]]:5: error: expected symbol assignment, entry, overlay or output section name
+CHECK-ERR-NEXT: {{^    : { \*\(\)}}}
+CHECK-ERR-NEXT: {{^    \^}}
+*/
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: r_brace: }
+CHECK: eof:
+*/

test/LinkerScript/missing-symbol.test

+/*
+  RUN: linker-script-test %s 2> %t | FileCheck %s
+  RUN: FileCheck -input-file %t -check-prefix=CHECK-ERR %s
+*/
+SECTIONS {
+    = foo + bar;
+/*
+CHECK-ERR: [[@LINE-2]]:5: error: expected symbol assignment, entry, overlay or output section name.
+CHECK-ERR-NEXT: {{^ = foo \+ bar;}}
+CHECK-ERR-NEXT: {{^ \^}}
+*/
+}
+
+/*
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: equal: =
+CHECK: identifier: foo
+CHECK: plus: +
+CHECK: identifier: bar
+CHECK: semicolon: ;
+CHECK: r_brace: }
+CHECK: eof:
+*/

test/LinkerScript/sections.test

+/*
+  This test exercises parsing typical commands found in GNU ld linker scripts.
+  RUN: linker-script-test %s | FileCheck %s
+*/
+
+SEARCH_DIR("/usr/x86_64-linux-gnu/lib64"); SEARCH_DIR("=/usr/local/lib/x86_64-linux-gnu");
+SECTIONS
+{
+  PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  .note.gnu.build-id : { *(.note.gnu.build-id) }
+  .hash           : { *(.hash) }
+  .rela.dyn       :
+    {
+      *(.rela.init)
+      *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+      *(.rela.fini)
+      *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+    }
+  .rela.plt       :
+    {
+      *(.rela.plt)
+      PROVIDE_HIDDEN (__rela_iplt_start = .);
+      *(.rela.iplt)
+      PROVIDE_HIDDEN (__rela_iplt_end = .);
+    }
+  .init           :
+  {
+    KEEP (*(SORT_NONE(.init)))
+  } =0x909090909090909090909090
+  PROVIDE (__etext = .);
+  .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
+  .exception_ranges   : ONLY_IF_RO { *(.exception_ranges
+  .exception_ranges*) }
+  . = ALIGN (CONSTANT (MAXPAGESIZE)) - ((CONSTANT (MAXPAGESIZE) - .) & (CONSTANT (MAXPAGESIZE) - 1)); . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
+  /* Exception handling  */
+  .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
+  .ctors          :
+  {
+    KEEP (*crtbegin.o(.ctors))
+    KEEP (*crtbegin?.o(.ctors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+  }
+  .dtors          :
+  {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*crtbegin?.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+  }
+  . = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
+  .got.plt        : { *(.got.plt)  *(.igot.plt) }
+  .lrodata   ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
+  {
+    *(.lrodata .lrodata.* .gnu.linkonce.lr.*)
+  }
+  .ldata   ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
+  {
+    *(.ldata .ldata.* .gnu.linkonce.l.*)
+    . = ALIGN(. != 0 ? 64 / 8 : 1);
+  }
+  . = ALIGN(64 / 8);
+  _end = .; PROVIDE (end = .);
+  . = DATA_SEGMENT_END (.);
+  /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
+}
+
+/*
+CHECK: kw_search_dir: SEARCH_DIR
+CHECK: l_paren: (
+CHECK: identifier: /usr/x86_64-linux-gnu/lib64
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: kw_search_dir: SEARCH_DIR
+CHECK: l_paren: (
+CHECK: identifier: =/usr/local/lib/x86_64-linux-gnu
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: kw_sections: SECTIONS
+CHECK: l_brace: {
+CHECK: kw_provide: PROVIDE
+CHECK: l_paren: (
+CHECK: identifier: __executable_start
+CHECK: equal: =
+CHECK: identifier: SEGMENT_START
+CHECK: l_paren: (
+CHECK: identifier: text-segment
+CHECK: comma: ,
+CHECK: number: 0x400000
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: SEGMENT_START
+CHECK: l_paren: (
+CHECK: identifier: text-segment
+CHECK: comma: ,
+CHECK: number: 0x400000
+CHECK: r_paren: )
+CHECK: plus: +
+CHECK: identifier: SIZEOF_HEADERS
+CHECK: semicolon: ;
+CHECK: identifier: .interp
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .interp
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .note.gnu.build-id
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .note.gnu.build-id
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .hash
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .hash
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .rela.dyn
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .rela.init
+CHECK: r_paren: )
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .rela.text
+CHECK: identifier: .rela.text.*
+CHECK: identifier: .rela.gnu.linkonce.t.*
+CHECK: r_paren: )
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .rela.fini
+CHECK: r_paren: )
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .rela.rodata
+CHECK: identifier: .rela.rodata.*
+CHECK: identifier: .rela.gnu.linkonce.r.*
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .rela.plt
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .rela.plt
+CHECK: r_paren: )
+CHECK: kw_provide_hidden: PROVIDE_HIDDEN
+CHECK: l_paren: (
+CHECK: identifier: __rela_iplt_start
+CHECK: equal: =
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .rela.iplt
+CHECK: r_paren: )
+CHECK: kw_provide_hidden: PROVIDE_HIDDEN
+CHECK: l_paren: (
+CHECK: identifier: __rela_iplt_end
+CHECK: equal: =
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: r_brace: }
+CHECK: identifier: .init
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: kw_sort_none: SORT_NONE
+CHECK: l_paren: (
+CHECK: identifier: .init
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: kw_provide: PROVIDE
+CHECK: l_paren: (
+CHECK: identifier: __etext
+CHECK: equal: =
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: .eh_frame
+CHECK: colon: :
+CHECK: kw_only_if_ro: ONLY_IF_RO
+CHECK: l_brace: {
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .eh_frame
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .exception_ranges
+CHECK: colon: :
+CHECK: kw_only_if_ro: ONLY_IF_RO
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .exception_ranges
+CHECK: identifier: .exception_ranges*
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: kw_align: ALIGN
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: minus: -
+CHECK: l_paren: (
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: minus: -
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: amp: &
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: minus: -
+CHECK: number: 1
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: DATA_SEGMENT_ALIGN
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: comma: ,
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: COMMONPAGESIZE
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: .eh_frame
+CHECK: colon: :
+CHECK: kw_only_if_rw: ONLY_IF_RW
+CHECK: l_brace: {
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .eh_frame
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .ctors
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: identifier: *crtbegin.o
+CHECK: l_paren: (
+CHECK: identifier: .ctors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: identifier: *crtbegin?.o
+CHECK: l_paren: (
+CHECK: identifier: .ctors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: kw_exclude_file: EXCLUDE_FILE
+CHECK: l_paren: (
+CHECK: identifier: *crtend.o
+CHECK: identifier: *crtend?.o
+CHECK: r_paren: )
+CHECK: identifier: .ctors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: kw_sort_by_name: SORT
+CHECK: l_paren: (
+CHECK: identifier: .ctors.*
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .ctors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .dtors
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: identifier: *crtbegin.o
+CHECK: l_paren: (
+CHECK: identifier: .dtors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: identifier: *crtbegin?.o
+CHECK: l_paren: (
+CHECK: identifier: .dtors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: kw_exclude_file: EXCLUDE_FILE
+CHECK: l_paren: (
+CHECK: identifier: *crtend.o
+CHECK: identifier: *crtend?.o
+CHECK: r_paren: )
+CHECK: identifier: .dtors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: kw_sort_by_name: SORT
+CHECK: l_paren: (
+CHECK: identifier: .dtors.*
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: kw_keep: KEEP
+CHECK: l_paren: (
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .dtors
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: DATA_SEGMENT_RELRO_END
+CHECK: l_paren: (
+CHECK: identifier: SIZEOF
+CHECK: l_paren: (
+CHECK: identifier: .got.plt
+CHECK: r_paren: )
+CHECK: greaterequal: >=
+CHECK: number: 24
+CHECK: question: ?
+CHECK: number: 24
+CHECK: colon: :
+CHECK: number: 0
+CHECK: comma: ,
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: .got.plt
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .got.plt
+CHECK: r_paren: )
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .igot.plt
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .lrodata
+CHECK: kw_align: ALIGN
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: plus: +
+CHECK: l_paren: (
+CHECK: identifier: .
+CHECK: amp: &
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: minus: -
+CHECK: number: 1
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .lrodata
+CHECK: identifier: .lrodata.*
+CHECK: identifier: .gnu.linkonce.lr.*
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: identifier: .ldata
+CHECK: kw_align: ALIGN
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: plus: +
+CHECK: l_paren: (
+CHECK: identifier: .
+CHECK: amp: &
+CHECK: l_paren: (
+CHECK: identifier: CONSTANT
+CHECK: l_paren: (
+CHECK: identifier: MAXPAGESIZE
+CHECK: r_paren: )
+CHECK: minus: -
+CHECK: number: 1
+CHECK: r_paren: )
+CHECK: r_paren: )
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .ldata
+CHECK: identifier: .ldata.*
+CHECK: identifier: .gnu.linkonce.l.*
+CHECK: r_paren: )
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: kw_align: ALIGN
+CHECK: l_paren: (
+CHECK: identifier: .
+CHECK: exclaimequal: !=
+CHECK: number: 0
+CHECK: question: ?
+CHECK: number: 64
+CHECK: slash: /
+CHECK: number: 8
+CHECK: colon: :
+CHECK: number: 1
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: r_brace: }
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: kw_align: ALIGN
+CHECK: l_paren: (
+CHECK: number: 64
+CHECK: slash: /
+CHECK: number: 8
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: _end
+CHECK: equal: =
+CHECK: identifier: .
+CHECK: semicolon: ;
+CHECK: kw_provide: PROVIDE
+CHECK: l_paren: (
+CHECK: identifier: end
+CHECK: equal: =
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: identifier: .
+CHECK: equal: =
+CHECK: identifier: DATA_SEGMENT_END
+CHECK: l_paren: (
+CHECK: identifier: .
+CHECK: r_paren: )
+CHECK: semicolon: ;
+CHECK: kw_discard: /DISCARD/
+CHECK: colon: :
+CHECK: l_brace: {
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .note.GNU-stack
+CHECK: r_paren: )
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .gnu_debuglink
+CHECK: r_paren: )
+CHECK: star: *
+CHECK: l_paren: (
+CHECK: identifier: .gnu.lto_*
+CHECK: r_paren: )
+CHECK: r_brace: }
+CHECK: r_brace: }
+CHECK: eof: 
+CHECK: SEARCH_DIR("/usr/x86_64-linux-gnu/lib64")
+CHECK: SEARCH_DIR("=/usr/local/lib/x86_64-linux-gnu")
+CHECK: SECTIONS
+CHECK: {
+CHECK: PROVIDE(__executable_start = SEGMENT_START(text-segment, 4194304))
+CHECK: . = (SEGMENT_START(text-segment, 4194304) + SIZEOF_HEADERS)
+CHECK: .interp :
+CHECK:   { 
+CHECK:     *(.interp)
+CHECK:   }
+CHECK: .note.gnu.build-id :
+CHECK:   { 
+CHECK:     *(.note.gnu.build-id)
+CHECK:   }
+CHECK: .hash :
+CHECK:   { 
+CHECK:     *(.hash)
+CHECK:   }
+CHECK: .rela.dyn :
+CHECK:   { 
+CHECK:     *(.rela.init)
+CHECK:     *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+CHECK:     *(.rela.fini)
+CHECK:     *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+CHECK:   }
+CHECK: .rela.plt :
+CHECK:   { 
+CHECK:     *(.rela.plt)
+CHECK:     PROVIDE_HIDDEN(__rela_iplt_start = .)
+CHECK:     *(.rela.iplt)
+CHECK:     PROVIDE_HIDDEN(__rela_iplt_end = .)
+CHECK:   }
+CHECK: .init :
+CHECK:   { 
+CHECK:     KEEP(*(SORT_NONE(.init)))
+CHECK:   } =0x909090909090909090909090
+CHECK: PROVIDE(__etext = .)
+CHECK: .eh_frame :
+CHECK: ONLY_IF_RO  { 
+CHECK:     KEEP(*(.eh_frame))
+CHECK:   }
+CHECK: .exception_ranges :
+CHECK: ONLY_IF_RO  { 
+CHECK:     *(.exception_ranges .exception_ranges*)
+CHECK:   }
+CHECK: . = (ALIGN(CONSTANT(MAXPAGESIZE)) - ((CONSTANT(MAXPAGESIZE) - .) & (CONSTANT(MAXPAGESIZE) - 1)))
+CHECK: . = DATA_SEGMENT_ALIGN(CONSTANT(MAXPAGESIZE), CONSTANT(COMMONPAGESIZE))
+CHECK: .eh_frame :
+CHECK: ONLY_IF_RW  { 
+CHECK:     KEEP(*(.eh_frame))
+CHECK:   }
+CHECK: .ctors :
+CHECK:   { 
+CHECK:     KEEP(*crtbegin.o(.ctors))
+CHECK:     KEEP(*crtbegin?.o(.ctors))
+CHECK:     KEEP(*(EXCLUDE_FILE(*crtend.o *crtend?.o ) .ctors))
+CHECK:     KEEP(*(SORT_BY_NAME(.ctors.*)))
+CHECK:     KEEP(*(.ctors))
+CHECK:   }
+CHECK: .dtors :
+CHECK:   { 
+CHECK:     KEEP(*crtbegin.o(.dtors))
+CHECK:     KEEP(*crtbegin?.o(.dtors))
+CHECK:     KEEP(*(EXCLUDE_FILE(*crtend.o *crtend?.o ) .dtors))
+CHECK:     KEEP(*(SORT_BY_NAME(.dtors.*)))
+CHECK:     KEEP(*(.dtors))
+CHECK:   }
+CHECK: . = DATA_SEGMENT_RELRO_END((SIZEOF(.got.plt) >= 24) ? 24 : 0, .)
+CHECK: .got.plt :
+CHECK:   { 
+CHECK:     *(.got.plt)
+CHECK:     *(.igot.plt)
+CHECK:   }
+CHECK: .lrodata (ALIGN(CONSTANT(MAXPAGESIZE)) + (. & (CONSTANT(MAXPAGESIZE) - 1))) :
+CHECK:   { 
+CHECK:     *(.lrodata .lrodata.* .gnu.linkonce.lr.*)
+CHECK:   }
+CHECK: .ldata (ALIGN(CONSTANT(MAXPAGESIZE)) + (. & (CONSTANT(MAXPAGESIZE) - 1))) :
+CHECK:   { 
+CHECK:     *(.ldata .ldata.* .gnu.linkonce.l.*)
+CHECK:     . = ALIGN((. != 0) ? (64 / 8) : 1)
+CHECK:   }
+CHECK: . = ALIGN((64 / 8))
+CHECK: _end = .
+CHECK: PROVIDE(end = .)
+CHECK: . = DATA_SEGMENT_END(.)
+CHECK:  :
+CHECK:   { 
+CHECK:     *(.note.GNU-stack)
+CHECK:     *(.gnu_debuglink)
+CHECK:     *(.gnu.lto_*)
+CHECK:   }
+CHECK: }
+*/