[ELF, LinkerScript] Support ! operator in linker script.

[abidh]

Summary

This small patch adds the support for ! operator in linker scripts.

[grimar]

test/ELF/linkerscript/assert.s

46 ↗

(On Diff #110150)

You can reuse FAIL I think.

# RUN: FileCheck %s -check-prefix=FAIL < %t.log

53 ↗

(On Diff #110150)

Excessive empty line.

test/ELF/linkerscript/symbol-assignexpr.s

18

All your new testcases using parentheses, is there some problem without them ?

[meadori]

Outside the comments @grimar made, LGTM.

[abidh]

Handle review comments.

[abidh]

test/ELF/linkerscript/assert.s

46 ↗

(On Diff #110150)

I tried but it was not immediately obvious how to do it.

test/ELF/linkerscript/symbol-assignexpr.s

18

The linker script parsing have problem where it can not separate these operator. You will see that test of ~ operator also use '(' or space in between. I have also changed one test to use space but this needs to be fixed as a separate problem.

[grimar]

test/ELF/linkerscript/assert.s

46 ↗

(On Diff #110150)

Following just works, no ?

# RUN: echo "SECTIONS { ASSERT(!(1), fail) }" > %t9.script
# RUN: not ld.lld -shared -o %t9 --script %t9.script %t1.o > %t.log 2>&1
# RUN: FileCheck %s -check-prefix=FAIL < %t.log

test/ELF/linkerscript/symbol-assignexpr.s

18

I fixed '~' here: D36508, I think you should be able to do the same for '!`

[ruiu]

test/ELF/linkerscript/assert.s

1 ↗

(On Diff #110337)

I wouldn't add any tests to this file as the feature is tested by symbol-assignexpr.s.

48–52 ↗

(On Diff #110337)

I wouldn't add this test -- the feature is tested enough with the above two tests.

test/ELF/linkerscript/symbol-assignexpr.s

18

Replace !symbol with !1 and add symbol14 = !0.

[ruiu]

ELF/ScriptLexer.cpp

215–217

I don't think this is correct. For example, I don't think this can handle expression 0!=1. You want to add code to tokenizeExpr instead of this function.

[abidh]

Fix case pointed out in review comments.

[abidh]

ELF/ScriptLexer.cpp

215–217

I think 0!=1 was failing even without my patch. I have fixed it now and added a test to check it.

[ruiu]

LGTM

ELF/ScriptLexer.cpp

195–199

This is probably a bit more straightforward:

if (S.substr(E).startswith("!=")) {
  Ret.push_back(S.substr(E, 2));
  S = S.substr(E + 2);
} else {
  Ret.push_back(S.substr(E, 1));
  S = S.substr(E + 1);
}

test/ELF/linkerscript/symbol-assignexpr.s

20

Thank you for adding this test.

ELF/ScriptLexer.cpp

 }
 
 // An erroneous token is handled as if it were the last token before EOF.
 bool ScriptLexer::atEOF() { return ErrorCount || Tokens.size() == Pos; }
 
 // Split a given string as an expression.
 // This function returns "3", "*" and "5" for "3*5" for example.
 static std::vector<StringRef> tokenizeExpr(StringRef S) {
-  StringRef Ops = "+-*/:"; // List of operators
+  StringRef Ops = "+-*/:!"; // List of operators
 
   // Quoted strings are literal strings, so we don't want to split it.
   if (S.startswith("\""))
     return {S};
 
   // Split S with +-*/ as separators.
   std::vector<StringRef> Ret;
   while (!S.empty()) {
     size_t E = S.find_first_of(Ops);
 
     // No need to split if there is no operator.
     if (E == StringRef::npos) {
       Ret.push_back(S);
       break;
     }
 
     // Get a token before the opreator.
     if (E != 0)
       Ret.push_back(S.substr(0, E));
 
     // Get the operator as a token.
     Ret.push_back(S.substr(E, 1));
     S = S.substr(E + 1);
   }
   return Ret;
 }
 
 // In contexts where expressions are expected, the lexer should apply
 // different tokenization rules than the default one. By default,
 // arithmetic operator characters are regular characters, but in the
 // expression context, they should be independent tokens.
 //
 // For example, "foo*3" should be tokenized to "foo", "*" and "3" only
 // in the expression context.
 //
 // This function may split the current token into multiple tokens.
 void ScriptLexer::maybeSplitExpr() {
   if (!InExpr || ErrorCount || atEOF())
     return;
 
   std::vector<StringRef> V = tokenizeExpr(Tokens[Pos]);
   if (V.size() == 1)
     return;
+  // Don't breakup != operator into 2 tokens
+  if (V.size() == 2 && V[0] == "!" && V[1] == "=")
+    return;
   Tokens.erase(Tokens.begin() + Pos);
   Tokens.insert(Tokens.begin() + Pos, V.begin(), V.end());
 }
 
 StringRef ScriptLexer::next() {
   maybeSplitExpr();
 
   if (ErrorCount)

ELF/ScriptParser.cpp

 Expr ScriptParser::readPrimary() {
   if (peek() == "(")
     return readParenExpr();
 
   if (consume("~")) {
     Expr E = readPrimary();
     return [=] { return ~E().getValue(); };
   }
+  if (consume("!")) {
+    Expr E = readPrimary();
+    return [=] { return !E().getValue(); };
+  }
   if (consume("-")) {
     Expr E = readPrimary();
     return [=] { return -E().getValue(); };
   }
 
   StringRef Tok = next();
   std::string Location = getCurrentLocation();
 

test/ELF/linkerscript/symbol-assignexpr.s

 # RUN:         symbol6 = symbol - ~(0xfff0 + 0xb); \
 # RUN:         symbol7 = symbol - ~ 0xfffb + 4; \
 # RUN:         symbol8 = ~ 0xffff + 4; \
 # RUN:         symbol9 = - 4; \
 # RUN:         symbol10 = 0xfedcba9876543210; \
 # RUN:         symbol11 = ((0x28000 + 0x1fff) & ~(0x1000 + -1)); \
 # RUN:         symbol12 = 0x1234; \
 # RUN:         symbol12 += 1; \
+# RUN:         symbol13 = !1; \
+# RUN:         symbol14 = !0; \
 # RUN:         bar = 0x5678; \
 # RUN:         baz = 0x9abc; \
 # RUN:       }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT: 0000000000000000 *UND* 00000000
 # CHECK-NEXT: 0000000000000000 .text 00000000 _start
 # CHECK-NEXT: 0000000000005678 *ABS* 00000000 bar
 # CHECK-NEXT: 0000000000009abc *ABS* 00000000 baz
 # CHECK-NEXT: 0000000000000001 .text 00000000 foo
 # CHECK-NEXT: 0000000000001000 *ABS* 00000000 symbol
 # CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol2
 # CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol3
 # CHECK-NEXT: 0000000000000ffc *ABS* 00000000 symbol4
 # CHECK-NEXT: 0000000000010ffc *ABS* 00000000 symbol5
 # CHECK-NEXT: 0000000000010ffc *ABS* 00000000 symbol6
 # CHECK-NEXT: 0000000000011000 *ABS* 00000000 symbol7
 # CHECK-NEXT: ffffffffffff0004 *ABS* 00000000 symbol8
 # CHECK-NEXT: fffffffffffffffc *ABS* 00000000 symbol9
 # CHECK-NEXT: fedcba9876543210 *ABS* 00000000 symbol10
 # CHECK-NEXT: 0000000000029000 *ABS* 00000000 symbol11
 # CHECK-NEXT: 0000000000001235 *ABS* 00000000 symbol12
+# CHECK-NEXT: 0000000000000000 *ABS* 00000000 symbol13
+# CHECK-NEXT: 0000000000000001 *ABS* 00000000 symbol14
 
 # RUN: echo "SECTIONS { symbol2 = symbol; }" > %t2.script
 # RUN: not ld.lld -o %t2 --script %t2.script %t 2>&1 \
 # RUN:  | FileCheck -check-prefix=ERR %s
 # ERR: {{.*}}.script:1: symbol not found: symbol
 
 .global _start
 _start: