[ELF] - Linker script expressions, ASSERT() command.

[grimar]

Summary

This patch implements linker script expressions and also ASSERT() command (is used to check the results for this patch).
Currently I think all possible operators are supported: ^, *, /, +, -, <<, >>, &, |, (, ), +=, -=, *=, /=, <<=, >>=, &=, |=.

This gives ability to assign values to variables and perform different calculations.
Sample of what is possible to do (test.script):

x = 1 + 2 * 3 - (4 - 5) ^ 1;
y = x << 2 & x | 15;
z = (((x + y) - x) + y) * 2;
x <<= (y + z / y);
x >>= (16 & 17);
x &= 0x7F;
x /= (0x1278 - 4696);
c = 1 >> 1;
ASSERT(x - c, "Custom error text");

This will error out "Custom error text" as "x-c" expression gives 0 after evaluation here.
Test cases for all operations are provided.

[ruiu]

Hi George,

This is probably too much at this moment. I'm not sure if we want to support ASSERT, but even if we want it, it is something we could add as a final step to complete the linker script support (until that point, we will have everything, so adding ASSERT would be very easy.) The expressions in ASSERT is the features users would use in other contexts. Because that is not plugged in to anywhere in your patch, your patch doesn't demonstrate that that would work for a minimal use case.

If you want to start working on the linker script support, can you start from writing a proposal about the overall design? It needs to be simple, easy to implement, and fast. I have a few ideas for that, but I don't have enough time to think deeply about them. Feel free to discuss your idea with me.

[davide]

100% agree. I'd also like to point out that even very complex linker scripts (as the one used by kernels) don't rely on this feature. I'm strongly opposed to see this in until some real consumer shows up. I'm in general opposed to having any linker script directive parsed properly until there's a real use case.
I can't stress enough that I'm disturbed by how badly linker script language "specification" evolved over time.

[emaste]

As a point of reference here's the FreeBSD kernel amd64 linker script: https://svnweb.freebsd.org/base/head/sys/conf/ldscript.amd64?view=co

[grimar]

In D16924#345138, @ruiu wrote:

Hi George,

This is probably too much at this moment. I'm not sure if we want to support ASSERT, but even if we want it, it is something we could add as a final step to complete the linker script support (until that point, we will have everything, so adding ASSERT would be very easy.) The expressions in ASSERT is the features users would use in other contexts. Because that is not plugged in to anywhere in your patch, your patch doesn't demonstrate that that would work for a minimal use case.

If you want to start working on the linker script support, can you start from writing a proposal about the overall design? It needs to be simple, easy to implement, and fast. I have a few ideas for that, but I don't have enough time to think deeply about them. Feel free to discuss your idea with me.

I didn`t want to support ASSERT, just had no idea how to check correctly that evaluations works and ASSERT was just simple solution to implement in context of this patch for validation purposes. I hoped to use the expressions in futher calculations, for example for location counter support. Thats why it is not plugged to anywhere else.
Probably you're right that overall design is the first step.

[grimar]

In D16924#345148, @davide wrote:

100% agree. I'd also like to point out that even very complex linker scripts (as the one used by kernels) don't rely on this feature. I'm strongly opposed to see this in until some real consumer shows up. I'm in general opposed to having any linker script directive parsed properly until there's a real use case.
I can't stress enough that I'm disturbed by how badly linker script language "specification" evolved over time.

Real use case for expressions is everywhere in linkerscript. ASSERT was implemented just for validation of results.

[davide]

In D16924#345171, @grimar wrote:

In D16924#345148, @davide wrote:

100% agree. I'd also like to point out that even very complex linker scripts (as the one used by kernels) don't rely on this feature. I'm strongly opposed to see this in until some real consumer shows up. I'm in general opposed to having any linker script directive parsed properly until there's a real use case.
I can't stress enough that I'm disturbed by how badly linker script language "specification" evolved over time.

Real use case for expressions is everywhere in linkerscript. ASSERT was implemented just for validation of results.

Sure. Expressions are used. My point is that it's better to support a subset of operators (at least in the beginning) rather than the whole set. If you look at the linker script posted by Ed, you'll notice only a small number of operators is really required. I'm not really familiar with Linux kernel linker script but I'd be really surprised if they make use of all the operators you implemented. I may be wrong.

In any case, I think we're still away from supporting such level of complexity and I'm inclined to keep the linker script code simple enough for people to contribute.

[grimar]

In D16924#345187, @davide wrote:

In D16924#345171, @grimar wrote:

In D16924#345148, @davide wrote:

100% agree. I'd also like to point out that even very complex linker scripts (as the one used by kernels) don't rely on this feature. I'm strongly opposed to see this in until some real consumer shows up. I'm in general opposed to having any linker script directive parsed properly until there's a real use case.
I can't stress enough that I'm disturbed by how badly linker script language "specification" evolved over time.

Real use case for expressions is everywhere in linkerscript. ASSERT was implemented just for validation of results.

Sure. Expressions are used. My point is that it's better to support a subset of operators (at least in the beginning) rather than the whole set. If you look at the linker script posted by Ed, you'll notice only a small number of operators is really required. I'm not really familiar with Linux kernel linker script but I'd be really surprised if they make use of all the operators you implemented. I may be wrong.

In any case, I think we're still away from supporting such level of complexity and I'm inclined to keep the linker script code simple enough for people to contribute.

Ok, I understood. But just in case all that specific operations is just a single line for each + record in map. For example "<<=" is:

else if (Op == ">>=")
        HaveResult = AssignResultOp(Arg1, getValue(Arg1) >> toInteger(Arg2));

..

std::map<StringRef, std::pair<uint8_t, bool>> Operators = { .... {"<<=", {0, false}} ....}

so I cant say there is a complexity because of them. If you want to see just a subset, it is easy to remove few lines. That`s easy with current implementation. At fact there is 230 lines of code for all evaluations.

[grimar]

In D16924#345157, @emaste wrote:

As a point of reference here's the FreeBSD kernel amd64 linker script: https://svnweb.freebsd.org/base/head/sys/conf/ldscript.amd64?view=co

Thanks, thats useful !

[grimar]

In D16924#345138, @ruiu wrote:

If you want to start working on the linker script support, can you start from writing a proposal about the overall design? It needs to be simple, easy to implement, and fast. I have a few > ideas for that, but I don't have enough time to think deeply about them. Feel free to discuss your idea with me.

I am not sure I can write good overall design for LS. I just hoped to go step by step.
For example I thought about implementation of location counter basing on this one patch.
But I have no global idea how this should work, linker script is very huge and I am not familiar with it it actually. I just can't imagine the whole picture right now.
If you have any ideas with what I can help with (not only LS, but actually any linker relative tasks), please feel free to share with me, I probably will be able to work on something.

ELF/LinkerScript.cpp

 #include "Config.h"
 #include "Driver.h"
 #include "SymbolTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 
+#include <map>
+
 using namespace llvm;
 using namespace lld;
 using namespace lld::elf2;
 
 namespace {
+class ExpressionEvaluator {
+public:
+  // Evaluates the expression given by list of tokens. Fills the Out
+  // with value of expression if succeded. Returns false on error.
+  bool evaluate(std::list<StringRef> &Tokens, int64_t *Out = nullptr) {
+    std::list<StringRef> RPN = buildRPN(Tokens);
+    std::list<StringRef> Stack;
+    std::list<std::string> Temps;
+
+    // Pushes integer value to stack.
+    auto PushStackVal = [&](int64_t Val) {
+      Temps.emplace_back(std::to_string(Val));
+      Stack.push_back(Temps.back());
+    };
+
+    // Checks that value is a valid integer
+    // or declared variable.
+    auto CheckDecl = [this](StringRef V) {
+      getValue(V);
+      return !HasError;
+    };
+
+    // Assigns result to values list and optional out variable.
+    // Returns true as assignment operation always means result.
+    auto AssignResultOp = [&](StringRef N, int64_t Val) {
+      Values[N] = Val;
+      if (Out)
+        *Out = Val;
+      return true;
+    };
+
+    // Tries to perform division operation. If returns true that means we
+    // have error result and do not need to continue.
+    auto DivOp = [this, PushStackVal](StringRef Arg1, StringRef Arg2) {
+      int64_t Val = getValue(Arg2);
+      if (!Val) {
+        error("Division by zero");
+        return true;
+      }
+      PushStackVal(getValue(Arg1) / Val);
+      return false;
+    };
+
+    for (StringRef Op : RPN) {
+      if (!isOperator(Op)) {
+        Stack.push_back(Op);
+        continue;
+      }
+
+      StringRef Arg2 = *std::prev(Stack.end(), 1);
+      StringRef Arg1 = *std::prev(Stack.end(), 2);
+      Stack.erase(std::prev(Stack.end(), 2), Stack.end());
+
+      // If this is not assignment we check that both
+      // operands are declared variables or a valid values.
+      if (Op != "=")
+        if (!CheckDecl(Arg1) || !CheckDecl(Arg2))
+          return false;
+
+      bool HaveResult = false;
+      if (Op == "=")
+        HaveResult = AssignResultOp(Arg1, toInteger(Arg2));
+      else if (Op == "-=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) - toInteger(Arg2));
+      else if (Op == "+=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) + toInteger(Arg2));
+      else if (Op == "*=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) * toInteger(Arg2));
+      else if (Op == "/=")
+        HaveResult = DivOp(Arg1, Arg2)
+                         ? true
+                         : AssignResultOp(Arg1, toInteger(Stack.back()));
+      else if (Op == "<<=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) << toInteger(Arg2));
+      else if (Op == ">>=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) >> toInteger(Arg2));
+      else if (Op == "|=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) | toInteger(Arg2));
+      else if (Op == "&=")
+        HaveResult = AssignResultOp(Arg1, getValue(Arg1) & toInteger(Arg2));
+      else if (Op == "+")
+        PushStackVal(getValue(Arg1) + getValue(Arg2));
+      else if (Op == "-")
+        PushStackVal(getValue(Arg1) - getValue(Arg2));
+      else if (Op == "*")
+        PushStackVal(getValue(Arg1) * getValue(Arg2));
+      else if (Op == "/")
+        HaveResult = DivOp(Arg1, Arg2);
+      else if (Op == "^")
+        PushStackVal(pow(getValue(Arg1), getValue(Arg2)));
+      else if (Op == "<<")
+        PushStackVal(getValue(Arg1) << getValue(Arg2));
+      else if (Op == ">>")
+        PushStackVal(getValue(Arg1) >> getValue(Arg2));
+      else if (Op == "&")
+        PushStackVal(getValue(Arg1) & getValue(Arg2));
+      else if (Op == "|")
+        PushStackVal(getValue(Arg1) | getValue(Arg2));
+      else
+        assert(false && "Unknown operator");
+
+      if (HaveResult)
+        return !HasError;
+    }
+
+    // If we reach here then that is expression without assignment, for example
+    // can be met in next statement: ASSERT(x + 5, "..."), where "x + 5" is it.
+    if (Stack.size() == 1) {
+      if (Out)
+        *Out = getValue(Stack.back());
+      return !HasError;
+    }
+
+    return false;
+  }
+
+  int64_t getValue(StringRef V) {
+    int64_t Val;
+    if (!V.getAsInteger(0, Val))
+      return Val;
+    auto I = Values.find(V);
+    if (I != Values.end())
+      return I->second;
+    error("Undeclared variable " + V);
+    return 0;
+  }
+
+protected:
+  // Builds Reverse Polish Notation using
+  // shunting-yard algorithm by Edsger Dijkstra.
+  // https://en.wikipedia.org/wiki/Shunting-yard_algorithm
+  std::list<StringRef> buildRPN(std::list<StringRef> &Tokens) {
+    std::list<StringRef> OutString;
+    std::list<StringRef> Stack;
+    int32_t OpenedBrackets = 0;
+
+    for (StringRef Tok : Tokens) {
+      // If the token is a number, then add it to the output queue.
+      if (!isOperator(Tok)) {
+        OutString.push_back(Tok);
+        continue;
+      }
+
+      if (isBracket(Tok)) {
+        // If the token is a left parenthesis, then push it onto the stack.
+        if (Tok == "(") {
+          ++OpenedBrackets;
+          Stack.push_back(Tok);
+        } else {
+          // If the token is a right parenthesis:
+          // Until the token at the top of the stack is a left parenthesis, pop
+          // operators off the stack onto the output queue.
+          // Pop the left parenthesis from the stack, but not onto the output
+          // queue.
+          --OpenedBrackets;
+          if (OpenedBrackets < 0)
+            error("Inconsistent opening/closing bracket");
+          while (!Stack.empty()) {
+            StringRef StackTok = Stack.back();
+            Stack.pop_back();
+            if (StackTok == "(")
+              break;
+            else
+              OutString.push_back(StackTok);
+          }
+        }
+        continue;
+      }
+
+      // If the token is an operator, Tok, then:
+      // while there is an operator token St, at the top of the operator stack:
+      // if either
+      //   1) Tok is left associative and its precedence is less than or equal to
+      //      that of St.
+      //   2) Tok is right associative, and has precedence less than that of St.
+      // Then pop StackTok off the operator stack, onto the output queue.
+      // At the end of iteration push Tok onto the operator stack.
+      auto ExtractStack = [this](StringRef Tok, StringRef StackTok) {
+        uint8_t Pr = getPriority(Tok);
+        bool LeftAssoc = isLeftAssoc(Tok);
+        uint8_t StackPr = getPriority(StackTok);
+        return (LeftAssoc && Pr <= StackPr) || (!LeftAssoc && Pr < StackPr);
+      };
+      while (!Stack.empty()) {
+        StringRef St = Stack.back();
+        if (ExtractStack(Tok, St)) {
+          OutString.push_back(St);
+          Stack.pop_back();
+          continue;
+        }
+        break;
+      }
+      Stack.push_back(Tok);
+    }
+
+    if (OpenedBrackets > 0)
+      error("Inconsistent opening/closing bracket");
+
+    // Add the remaining stack content to output string.
+    OutString.insert(OutString.end(), Stack.rbegin(), Stack.rend());
+    return OutString;
+  }
+
+  bool isOperator(StringRef O) { return Operators.find(O) != Operators.end(); }
+  bool isLeftAssoc(StringRef O) { return Operators.find(O)->second.second; }
+  uint8_t getPriority(StringRef O) { return Operators.find(O)->second.first; }
+  bool isBracket(StringRef B) { return B == "(" || B == ")"; }
+
+  bool isInteger(StringRef Tok) {
+    int64_t Val;
+    return !Tok.getAsInteger(0, Val);
+  }
+
+  int64_t toInteger(StringRef Tok) {
+    int64_t Val;
+    if (Tok.getAsInteger(0, Val))
+      error("Integer can't be parsed: " + Tok);
+    return Val;
+  }
+
+  // Operator Name->[Rank, IsLeftAssociative] pair.
+  std::map<StringRef, std::pair<uint8_t, bool>> Operators = {
+      {"^", {100, true}}, {"*", {80, true}},   {"/", {80, true}},
+      {"+", {50, true}},  {"-", {50, true}},   {"<<", {30, true}},
+      {">>", {30, true}}, {"&", {30, true}},   {"|", {30, true}},
+      {"(", {20, true}},  {")", {20, true}},   {"=", {0, false}},
+      {"+=", {0, false}}, {"-=", {0, false}},  {"*=", {0, false}},
+      {"/=", {0, false}}, {"<<=", {0, false}}, {">>=", {0, false}},
+      {"&=", {0, false}}, {"|=", {0, false}}};
+
+  std::map<StringRef, uint64_t> Values;
+};
+
 class LinkerScript {
 public:
   LinkerScript(BumpPtrAllocator *A, StringRef S, bool B)
       : Saver(*A), Tokens(tokenize(S)), IsUnderSysroot(B) {}
   void run();
 
 private:
   void setError(const Twine &Msg);
   static std::vector<StringRef> tokenize(StringRef S);
   static StringRef skipSpace(StringRef S);
   bool atEOF();
   StringRef next();
   bool skip(StringRef Tok);
   void expect(StringRef Expect);
 
   void addFile(StringRef Path);
 
   void readAsNeeded();
+  void readAssert();
   void readEntry();
+  bool readExpression(StringRef Tok);
   void readExtern();
   void readGroup();
   void readInclude();
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readSearchDir();
   void readSections();
 
   void readOutputSectionDescription();
 
   StringSaver Saver;
   std::vector<StringRef> Tokens;
   bool Error = false;
   size_t Pos = 0;
   bool IsUnderSysroot;
+
+  ExpressionEvaluator Eval;
 };
 }
 
 void LinkerScript::run() {
   while (!atEOF()) {
     StringRef Tok = next();
     if (Tok == ";")
       continue;
-    if (Tok == "ENTRY") {
+    if (Tok == "ASSERT") {
+      readAssert();
+    } else if (Tok == "ENTRY") {
       readEntry();
     } else if (Tok == "EXTERN") {
       readExtern();
     } else if (Tok == "GROUP" || Tok == "INPUT") {
       readGroup();
     } else if (Tok == "INCLUDE") {
       readInclude();
     } else if (Tok == "OUTPUT") {
       readOutput();
     } else if (Tok == "OUTPUT_ARCH") {
       readOutputArch();
     } else if (Tok == "OUTPUT_FORMAT") {
       readOutputFormat();
     } else if (Tok == "SEARCH_DIR") {
       readSearchDir();
     } else if (Tok == "SECTIONS") {
       readSections();
     } else {
+      if (!readExpression(Tok)) {
         setError("unknown directive: " + Tok);
         return;
       }
     }
   }
+}
 
 // We don't want to record cascading errors. Keep only the first one.
 void LinkerScript::setError(const Twine &Msg) {
   if (Error)
     return;
   error(Msg);
   Error = true;
 }
if (S.startswith("\"")) {
       Ret.push_back(S.substr(1, E - 1));
       S = S.substr(E + 1);
       continue;
     }
 
     // Unquoted token
     size_t Pos = S.find_first_not_of(
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-        "0123456789_.$/\\~=+[]*?-:");
+        "0123456789_.$/\\~=+[]*?-:><|&");
     // A character that cannot start a word (which is usually a
     // punctuation) forms a single character token.
     if (Pos == 0)
       Pos = 1;
     Ret.push_back(S.substr(0, Pos));
     S = S.substr(Pos);
   }
 }
while (!Error) {
     StringRef Tok = next();
     if (Tok == ")")
       break;
     addFile(Tok);
   }
   Config->AsNeeded = Orig;
 }
 
+void LinkerScript::readAssert() {
+  expect("(");
+  std::list<StringRef> ExpList;
+  while (!Error) {
+    StringRef Tok = next();
+    if (Tok == ",")
+      break;
+    else
+      ExpList.push_back(Tok);
+  }
+  StringRef Text = next();
+  expect(")");
+  int64_t Cond;
+  if (Eval.evaluate(ExpList, &Cond) && !Cond)
+    error(Text);
+}
+
 void LinkerScript::readEntry() {
   // -e <symbol> takes predecence over ENTRY(<symbol>).
   expect("(");
   StringRef Tok = next();
   if (Config->Entry.empty())
     Config->Entry = Tok;
   expect(")");
 }
 
+bool LinkerScript::readExpression(StringRef Tok) {
+  std::list<StringRef> ExpList;
+  ExpList.push_back(Tok);
+  while (!Error) {
+    StringRef Tok = next();
+    if (Tok == ";")
+      break;
+    else
+      ExpList.push_back(Tok);
+  }
+  return !Error && Eval.evaluate(ExpList);
+}
+
 void LinkerScript::readExtern() {
   expect("(");
   while (!Error) {
     StringRef Tok = next();
     if (Tok == ")")
       return;
     Config->Undefined.push_back(Tok);
   }

test/ELF/linkerscript-expressions.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## No errors when assert expression is not 0.
+# RUN: echo "ASSERT(26, "OK"); \
+# RUN: " > %t.script
+# RUN: ld.lld -o %t.out --script %t.script %t
+# RUN: llvm-readobj %t.out > /dev/null
+
+## No errors when assert expression is not 0
+## and variable is used, also checks that
+## assignment works.
+# RUN: echo "x = 1; \
+# RUN:  ASSERT(x, "OK"); \
+# RUN: " > %t.script
+# RUN: ld.lld -o %t.out --script %t.script %t
+# RUN: llvm-readobj %t.out > /dev/null
+
+## Error when assert expression is single undeclared variable.
+# RUN: echo "ASSERT(undecl, "OK"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=UNDECLARED %s < %t.log
+# UNDECLARED: Undeclared variable undecl
+
+## Error when assert expression is 0, also checks that
+## text from assert is valid and customizable.
+# RUN: echo "ASSERT(0, \"Custom assert fail text\"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE-CUSTOM %s < %t.log
+# FALSE-CUSTOM: Custom assert fail text
+
+## Error when undeclared variable used.
+# RUN: echo "x = 5; \
+# RUN:   x = 10 + undecl; \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=UNDECLARED %s < %t.log
+
+## This check is used below to verify output from assert
+## expression when it fails.
+# FALSE: false
+
+## Check operation '+' works as expected. Also checks
+## assignment of negative values.
+# RUN: echo "x = -100; \
+# RUN:  ASSERT(100 + x, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check operation '-' works as expected.
+# RUN: echo "x = 100; \
+# RUN:  ASSERT(100 - x, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check operation '-' works as expected.
+# RUN: echo "x = 100; \
+# RUN:  ASSERT(100 - x, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check operation '*' works as expected.
+# RUN: echo "x = 10 * 5; \
+# RUN:  ASSERT(50 - x - x * 0, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check operation '/' works as expected.
+# RUN: echo "x = 10 / 5; \
+# RUN:  ASSERT(x - 2, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check operation '^' works as expected.
+# RUN: echo "x = 2 ^ 5; \
+# RUN:  ASSERT(32 - x, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Division by 0 error
+# RUN: echo "x = 10 / 0;" > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=DIV-ZERO %s < %t.log
+# DIV-ZERO: Division by zero
+
+## Error - inconsistent closing bracket
+# RUN: echo "x = 10 + 5);" > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=WRONG-BRACKETS %s < %t.log
+# WRONG-BRACKETS: Inconsistent opening/closing bracket
+
+## Error - inconsistent opening bracket
+# RUN: echo "x = (10 + 5;" > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=WRONG-BRACKETS %s < %t.log
+
+## Check ')' and '(' works as expected.
+# RUN: echo "x = ((5 + 5) * 5) - 5 * 2 / (5 + 5); \
+# RUN:  ASSERT(x - 49, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '-=' works as expected.
+# RUN: echo "x = 5; \
+# RUN:  x -= 5; \
+# RUN:  ASSERT(x, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '+=' works as expected.
+# RUN: echo "x = -5; \
+# RUN:  x += 5; \
+# RUN:  ASSERT(x, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '*=' works as expected.
+# RUN: echo "x = 5; \
+# RUN:  x *= 5; \
+# RUN:  ASSERT(x - 25, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '/=' works as expected.
+# RUN: echo "x = 25; \
+# RUN:  x /= 5; \
+# RUN:  ASSERT(x - 5, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '/=' division by 0 error.
+# RUN: echo "x = 25; \
+# RUN:  x /= 0; \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=DIV-ZERO %s < %t.log
+
+## Check '<<' works as expected.
+# RUN: echo "x = 10 - 2 * 4 << 1; \
+# RUN:  ASSERT(x - 4, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '>>' works as expected.
+# RUN: echo "x = 10 - 2 * 4 >> 1; \
+# RUN:  ASSERT(x - 1, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '<<=' works as expected.
+# RUN: echo "x = 1; \
+# RUN:  x <<= 5; \
+# RUN:  ASSERT(x - 32, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '>>=' works as expected.
+# RUN: echo "x = 32; \
+# RUN:  x >>= 5; \
+# RUN:  ASSERT(x - 1, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '|=' works as expected.
+# RUN: echo "x = 5; \
+# RUN:  x |= 8; \
+# RUN:  ASSERT(x - 13, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '&=' works as expected.
+# RUN: echo "x = 6; \
+# RUN:  x &= 3; \
+# RUN:  ASSERT(x - 2, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Check '&' works as expected.
+# RUN: echo "x = 5 * 7 & 6; \
+# RUN:  ASSERT(x - 2, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+## Complex test with many types of operators, several operands
+## and with hex values.
+# RUN: echo "x = 1 + 2 * 3 - (4 - 5) ^ 1; \
+# RUN:  y = x << 2 & x | 15; \
+# RUN:  z = (((x + y) - x) + y) * 2; \
+# RUN:  x <<= (y + z / y); \
+# RUN:  x >>= (16 & 17); \
+# RUN:  x &= 0x7F; \
+# RUN:  x /= (0x1278 - 4696); \
+# RUN:  c = 1 << 1; \
+# RUN:  ASSERT(x - c, "false"); \
+# RUN: " > %t.script
+# RUN: not ld.lld -o %t.out --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=FALSE %s < %t.log
+
+.globl _start;
+_start:
+ nop

test/ELF/linkerscript.s

 # RUN: echo "GROUP(\"%t\")" > %t.script2
 # RUN: ld.lld %t.script1
 # RUN: llvm-readobj %t2 > /dev/null
 
 # RUN: echo "FOO(BAR)" > %t.script
 # RUN: not ld.lld -o foo %t.script > %t.log 2>&1
 # RUN: FileCheck -check-prefix=ERR1 %s < %t.log
 
-# ERR1: unknown directive: FOO
+# ERR1: unexpected EOF
 
 .globl _start, _label;
 _start:
   mov $60, %rax
   mov $42, %rdi
 _label:
   syscall