[ELF] Better error reporting for linker scripts

[evgeny777]

Summary

This patch shows both file and line for linker script errors, including:

• Errors occurred in lexer (ScriptParserBase::tokenize)
• Errors occurred in included files (via INCLUDE directive)

See updated test cases in diagnostics.s

[grimar]

ELF/LinkerScript.cpp

1140

In one of my latest patches I found that it is confusing to have multiple lines in output that are starting from "error: xxx".
I think we should not call error() for more than a single error at once.

1159

<removed (have some issue with applying del on comment in phab, it does not want to do that. I have no time to wait until it do, so had to edit in that way)>

[evgeny777]

ELF/LinkerScript.cpp

1140

Here multiple lines are used to highlight error position, which might be useful, especially when you run linker from command line. I would keep this bearing in mind that we already have tests for it.

[ruiu]

I wonder if we can remove INCLUDE directive from the linker script. I added that without thinking about it, but I've never seen any use of it. Linker scripts that add other linker scripts usually add that with INPUT() directive.

[evgeny777]

This is a question, I cannot answer :). You can't replace INCLUDE with INPUT and vice versa, but if you remove it then this patch will be much simpler.

[ruiu]

Let's try to remove it to see if we actually need it. Yeah, courage.

[evgeny777]

Looks like I found few projects which use INCLUDE directive:

http://libopencm3.org/wiki/Run_From_RAM
https://github.com/cobyism/edimax-br-6528n/blob/master/AP/mkimg/RTL8196C_1200_tools/libstrip/libstrip
https://github.com/RIOT-OS/RIOT/blob/master/cpu/stm32f4/ldscripts/stm32f415rg.ld
https://chromium.googlesource.com/chromiumos/third_party/coreboot/+/firmware-uboot_v2-1299.B/src/arch/x86/Makefile.bootblock.inc

The last one seems to be a chromebook boot loader: it includes script files in auto-generated linker script ldscript.ld

I don't know how important is to support those in lld, but please confirm that you want to get rid of INCLUDE

[ruiu]

I'm not speaking for Google, but Chromebook boot loader is probably a large user we can't ignore, so I'm inclined to not remove INCLUDE. I'll review your patch tomorrow.

[evgeny777]

Simplified and add test case

[• rafael]

ELF/LinkerScript.cpp

1010

That is pretty much what a MemomryBufferRef is. Can't you store that instead of the std::pair?

[ruiu]

ELF/LinkerScript.cpp

1117

Currently, error reporting is zero-cost if there's no error (we find an error location after an error is raised), and that seemed to be a nice hack to use a StringRef's pointer to find a location. However, it didn't work well for INCLUDE as you know. I think we don't want to keep the hack that's proved to be working not well.

Linker scripts are small, so it is OK to do more and use more memory when tokenizing them.

How about this? We can change tokenize to return not only tokens but token locations as a parallel array, like this.

std::pair<std::vector<StringRef>, std::vector<std::string>>
tokenize(MemoryBufferRef MB);

ScriptParser class then store the vectors to Tokens and LineNo.

[evgeny777]

ScriptParser class then store the vectors to Tokens and LineNo.

You also have to store file name for each token and I think this is too much. How about storing a vector of MemoryBufferRef instead of 'Input' in ScriptParserBase? Please take a look at the updated diff.

[evgeny777]

Moved file management to ScriptParserBase. Now errors in version scripts and dynamic lists are handled in a new way as well

[ruiu]

It's much better than before, but I still think that we could do more by using parallel arrays. We want to maintain four tuples (filename, line content, line number, column number) for each token, and all of them are small (they are intetgers and StringRefs). So I think it's not going to be too much.

That being said, we can do that later. It is indeed a very good improvement. Thanks!

LGTM

ELF/ScriptParser.cpp

159

I'd rather just use Tokens[Pos - 1] instead of current() everywhere because this function is used from those who already know internals of this class.

ELF/ScriptParser.h

32

Make this private.

36

Ditto

ELF/DriverUtils.cpp

 //
 //  { symbol1; symbol2; [...]; symbolN };
 //
 // Multiple groups can be defined in the same file, and they are merged
 // into a single group.
 void elf::parseDynamicList(MemoryBufferRef MB) {
   class Parser : public ScriptParserBase {
   public:
-    Parser(StringRef S) : ScriptParserBase(S) {}
+    Parser(MemoryBufferRef MB) : ScriptParserBase(MB) {}
 
     void run() {
       while (!atEOF()) {
         expect("{");
         while (!Error && !consume("}")) {
           Config->DynamicList.push_back(unquote(next()));
           expect(";");
         }
         expect(";");
       }
     }
   };
 
-  Parser(MB.getBuffer()).run();
+  Parser(MB).run();
 }
 
 void elf::printHelp(const char *Argv0) {
   ELFOptTable Table;
   Table.PrintHelp(outs(), Argv0, "lld", false);
 }
 
 // Reconstructs command line arguments so that so that you can re-run

ELF/LinkerScript.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MathExtras.h"
-#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <limits>
 #include <memory>
for (PhdrsCommand &Cmd : Opt.PhdrsCommands) {
     if (Cmd.Name == PhdrName)
       return I;
     ++I;
   }
   error("section header '" + PhdrName + "' is not listed in PHDRS");
   return 0;
 }
 
-class elf::ScriptParser : public ScriptParserBase {
+class elf::ScriptParser final : public ScriptParserBase {
   typedef void (ScriptParser::*Handler)();
 
 public:
-  ScriptParser(StringRef S, bool B) : ScriptParserBase(S), IsUnderSysroot(B) {}
+  ScriptParser(MemoryBufferRef MB, bool B)
+      : ScriptParserBase(MB), IsUnderSysroot(B) {}
 
   void readLinkerScript();
   void readVersionScript();
 
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
private:
   // For parsing version script.
   std::vector<SymbolVersion> readVersionExtern();
   void readAnonymousDeclaration();
   void readVersionDeclaration(StringRef VerStr);
   std::vector<SymbolVersion> readSymbols();
 
   ScriptConfiguration &Opt = *ScriptConfig;
   bool IsUnderSysroot;
+  std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
 void ScriptParser::readVersionScript() {
   readVersionScriptCommand();
   if (!atEOF())
     setError("EOF expected, but got " + next());
 }
 
 void ScriptParser::readVersionScriptCommand() {

 void ScriptParser::readAsNeeded() {
   expect("(");
   bool Orig = Config->AsNeeded;
   Config->AsNeeded = true;
   while (!Error && !consume(")"))
     addFile(unquote(next()));
   Config->AsNeeded = Orig;
 }
 
 void ScriptParser::readEntry() {
   // -e <symbol> takes predecence over ENTRY(<symbol>).
   expect("(");
   StringRef Tok = next();
   if (Config->Entry.empty())
     Config->Entry = Tok;
   expect(")");
 }
 
 void ScriptParser::readExtern() {
   expect("(");
   while (!Error && !consume(")"))
     Config->Undefined.push_back(next());
 }
 
 void ScriptParser::readGroup() {
   expect("(");
   while (!Error && !consume(")")) {
     StringRef Tok = next();
     if (Tok == "AS_NEEDED")
       readAsNeeded();
     else
       addFile(unquote(Tok));
   }
 }
 
 void ScriptParser::readInclude() {
   StringRef Tok = next();
   auto MBOrErr = MemoryBuffer::getFile(unquote(Tok));
   if (!MBOrErr) {
     setError("cannot open " + Tok);
     return;
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
-  StringRef S = Saver.save(MB->getMemBufferRef().getBuffer());
-  std::vector<StringRef> V = tokenize(S);
-  Tokens.insert(Tokens.begin() + Pos, V.begin(), V.end());
+  tokenize(MB->getMemBufferRef());
+  OwningMBs.push_back(std::move(MB));
 }
 
 void ScriptParser::readOutput() {
   // -o <file> takes predecence over OUTPUT(<file>).
   expect("(");
   StringRef Tok = next();
   if (Config->OutputFile.empty())
     Config->OutputFile = unquote(Tok);
   expect(")");
 }
 
 void ScriptParser::readOutputArch() {
   // Error checking only for now.
   expect("(");
static bool isUnderSysroot(StringRef Path) {
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;
   return false;
 }
 
 void elf::readLinkerScript(MemoryBufferRef MB) {
   StringRef Path = MB.getBufferIdentifier();
-  ScriptParser(MB.getBuffer(), isUnderSysroot(Path)).readLinkerScript();
+  ScriptParser(MB, isUnderSysroot(Path)).readLinkerScript();
 }
 
 void elf::readVersionScript(MemoryBufferRef MB) {
-  ScriptParser(MB.getBuffer(), false).readVersionScript();
+  ScriptParser(MB, false).readVersionScript();
 }
 
 template class elf::LinkerScript<ELF32LE>;
 template class elf::LinkerScript<ELF32BE>;
 template class elf::LinkerScript<ELF64LE>;
 template class elf::LinkerScript<ELF64BE>;

ELF/ScriptParser.h

 //===- ScriptParser.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SCRIPT_PARSER_H
 #define LLD_ELF_SCRIPT_PARSER_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include <utility>
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class ScriptParserBase {
 public:
-  explicit ScriptParserBase(StringRef S) : Input(S), Tokens(tokenize(S)) {}
+  explicit ScriptParserBase(MemoryBufferRef &MB);
 
-protected:
   void setError(const Twine &Msg);
-  static std::vector<StringRef> tokenize(StringRef S);
+  void tokenize(MemoryBufferRef MB);
   static StringRef skipSpace(StringRef S);
   bool atEOF();
   StringRef next();
   StringRef peek();
+  StringRef current();
   void skip();
   bool consume(StringRef Tok);
   void expect(StringRef Expect);
+  MemoryBufferRef currentBuffer();
 
-  size_t getPos();
-  void printErrorPos();
-
-  StringRef Input;
+  std::vector<MemoryBufferRef> MBs;
   std::vector<StringRef> Tokens;
   size_t Pos = 0;
   bool Error = false;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/ScriptParser.cpp

 #include "ScriptParser.h"
 #include "Error.h"
 #include "llvm/ADT/Twine.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::elf;
 
-// Returns the line that the character S[Pos] is in.
-static StringRef getLine(StringRef S, size_t Pos) {
-  size_t Begin = S.rfind('\n', Pos);
-  size_t End = S.find('\n', Pos);
+// Returns the line that the token Tok is in.
+static StringRef getLine(StringRef Data, StringRef Tok) {
+  size_t Pos = Tok.data() - Data.data();
+  size_t Begin = Data.rfind('\n', Pos);
+  size_t End = Data.find('\n', Pos);
   Begin = (Begin == StringRef::npos) ? 0 : Begin + 1;
   if (End == StringRef::npos)
-    End = S.size();
+    End = Data.size();
   // rtrim for DOS-style newlines.
-  return S.substr(Begin, End - Begin).rtrim();
+  return Data.substr(Begin, End - Begin).rtrim();
 }
 
-void ScriptParserBase::printErrorPos() {
-  StringRef Tok = Tokens[Pos == 0 ? 0 : Pos - 1];
-  StringRef Line = getLine(Input, Tok.data() - Input.data());
-  size_t Col = Tok.data() - Line.data();
-  error(Line);
-  error(std::string(Col, ' ') + "^");
+static std::pair<size_t, size_t> getPos(StringRef Data, StringRef Tok) {
+  StringRef Line = getLine(Data, Tok);
+  size_t LineNo =
+      StringRef(Data.data(), Tok.data() - Data.data()).count('\n') + 1;
+  return {LineNo, Tok.data() - Line.data()};
 }
 
+ScriptParserBase::ScriptParserBase(MemoryBufferRef &MB) { tokenize(MB); }
+
 // We don't want to record cascading errors. Keep only the first one.
 void ScriptParserBase::setError(const Twine &Msg) {
   if (Error)
     return;
-  if (Input.empty() || Tokens.empty()) {
-    error(Msg);
-  } else {
-    error("line " + Twine(getPos()) + ": " + Msg);
-    printErrorPos();
+
+  std::pair<size_t, size_t> ErrPos;
+  MemoryBufferRef MB = currentBuffer();
+  std::string Location = MB.getBufferIdentifier();
+  if (Pos) {
+    ErrPos = getPos(MB.getBuffer(), current());
+    Location += ":";
+    Location += std::to_string(ErrPos.first);
+  }
+  error(Location + ": " + Msg);
+  if (Pos) {
+    error(Location + ": " + getLine(MB.getBuffer(), current()));
+    error(Location + ": " + std::string(ErrPos.second, ' ') + "^");
   }
+
   Error = true;
 }
 
 // Split S into linker script tokens.
-std::vector<StringRef> ScriptParserBase::tokenize(StringRef S) {
+void ScriptParserBase::tokenize(MemoryBufferRef MB) {
   std::vector<StringRef> Ret;
+  MBs.push_back(MB);
+  StringRef S = MB.getBuffer();
+  StringRef Begin = S;
   for (;;) {
     S = skipSpace(S);
     if (S.empty())
-      return Ret;
+      break;
 
     // Quoted token. Note that double-quote characters are parts of a token
     // because, in a glob match context, only unquoted tokens are interpreted
     // as glob patterns. Double-quoted tokens are literal patterns in that
     // context.
     if (S.startswith("\"")) {
       size_t E = S.find("\"", 1);
       if (E == StringRef::npos) {
-        error("unclosed quote");
-        return {};
+        auto ErrPos = getPos(Begin, S);
+        error(MB.getBufferIdentifier() + ":" + Twine(ErrPos.first) +
+              ": unclosed quote");
+        return;
       }
       Ret.push_back(S.take_front(E + 1));
       S = S.substr(E + 1);
       continue;
     }
 
     // Unquoted token. This is more relaxed than tokens in C-like language,
     // so that you can write "file-name.cpp" as one bare token, for example.
     size_t Pos = S.find_first_not_of(
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
         "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);
   }
+  Tokens.insert(Tokens.begin() + Pos, Ret.begin(), Ret.end());
 }
 
 // Skip leading whitespace characters or comments.
 StringRef ScriptParserBase::skipSpace(StringRef S) {
   for (;;) {
     if (S.startswith("/*")) {
       size_t E = S.find("*/", 2);
       if (E == StringRef::npos) {

 StringRef ScriptParserBase::peek() {
   StringRef Tok = next();
   if (Error)
     return "";
   --Pos;
   return Tok;
 }
 
+StringRef ScriptParserBase::current() {
+  assert(Pos);
+  return Tokens[Pos - 1];
+}
+
 bool ScriptParserBase::consume(StringRef Tok) {
   if (peek() == Tok) {
     skip();
     return true;
   }
   return false;
 }
 
 void ScriptParserBase::skip() { (void)next(); }
 
 void ScriptParserBase::expect(StringRef Expect) {
   if (Error)
     return;
   StringRef Tok = next();
   if (Tok != Expect)
     setError(Expect + " expected, but got " + Tok);
 }
 
-// Returns the current line number.
-size_t ScriptParserBase::getPos() {
-  if (Pos == 0)
-    return 1;
-  const char *Begin = Input.data();
-  const char *Tok = Tokens[Pos - 1].data();
-  return StringRef(Begin, Tok - Begin).count('\n') + 1;
+// Returns true if string 'Bigger' contains string 'Shorter'.
+static bool containsString(StringRef Bigger, StringRef Shorter) {
+  const char *BiggerEnd = Bigger.data() + Bigger.size();
+  const char *ShorterEnd = Shorter.data() + Shorter.size();
+
+  return Bigger.data() <= Shorter.data() && BiggerEnd >= ShorterEnd;
+}
+
+MemoryBufferRef ScriptParserBase::currentBuffer() {
+  // Find input buffer containing the current token.
+  assert(!MBs.empty());
+  if (Pos)
+    for (MemoryBufferRef MB : MBs)
+      if (containsString(MB.getBuffer(), current()))
+        return MB;
+
+  return MBs.front();
 }

test/ELF/invalid-dynamic-list.test

 ## Different "echo" commands on Windows interpret quoted strings and
 ## wildcards in similar but different way (On Windows, ARGV tokenization
 ## and wildcard expansion are not done by the shell but by each command.)
 ## Because of that reason, this test fails on some Windows environment.
 ## We can't write quoted strings that are interpreted the same way
 ## by all echo commands. So, we don't want to run this on Windows.
 
 # REQUIRES: shell
 
 # RUN: mkdir -p %t.dir
 
 # RUN: echo foobar > %t1
 # RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR1 %s
-# ERR1: line 1: { expected, but got foobar
+# ERR1: {{.*}}:1: { expected, but got foobar
 
 # RUN: echo "{ foobar;" > %t1
 # RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR2 %s
-# ERR2: line 1: unexpected EOF
+# ERR2: {{.*}}:1: unexpected EOF
 
 ## Missing ';' before '}'
 # RUN: echo "{ foobar }" > %t1
 # RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR3 %s
-# ERR3: line 1: ; expected, but got }
+# ERR3: {{.*}}:1: ; expected, but got }
 
 ## Missing final ';'
 # RUN: echo "{ foobar; }" > %t1
 # RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR4 %s
-# ERR4: line 1: unexpected EOF
+# ERR4: {{.*}}:1: unexpected EOF
 
 ## Missing \" in foobar definition
 # RUN echo "{ \"foobar; };" > %t1
 # RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR5 %s
-# ERR5: line 1: unexpected EOF
+# ERR5: {{.*}}:1: unexpected EOF
 
 # RUN: echo "{ extern \"BOGUS\" { test }; };" > %t1
 # RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR6 %s
-# ERR6: line 1: ; expected, but got "BOGUS"
+# ERR6: {{.*}}:1: ; expected, but got "BOGUS"

test/ELF/linkerscript/diagnostic.s

 ## message starts from correct line number:
 # RUN: echo "SECTIONS {" > %t.script
 # RUN: echo ".text + { *(.text) }" >> %t.script
 # RUN: echo ".keep : { *(.keep) } /*" >> %t.script
 # RUN: echo "comment line 1" >> %t.script
 # RUN: echo "comment line 2 */" >> %t.script
 # RUN: echo ".temp : { *(.temp) } }" >> %t.script
 # RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | FileCheck -check-prefix=ERR1 %s
-# ERR1: line 2:
+# ERR1: {{.*}}.script:2:
 
 ## Change ":" to "+" at line 3 now, check correct error line number:
 # RUN: echo "SECTIONS {" > %t.script
 # RUN: echo ".text : { *(.text) }" >> %t.script
 # RUN: echo ".keep + { *(.keep) } /*" >> %t.script
 # RUN: echo "comment line 1" >> %t.script
 # RUN: echo "comment line 2 */" >> %t.script
 # RUN: echo ".temp : { *(.temp) } }" >> %t.script
 # RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | FileCheck -check-prefix=ERR2 %s
-# ERR2: line 3:
+# ERR2: {{.*}}.script:3:
 
 ## Change ":" to "+" at line 6, after multiline comment,
 ## check correct error line number:
 # RUN: echo "SECTIONS {" > %t.script
 # RUN: echo ".text : { *(.text) }" >> %t.script
 # RUN: echo ".keep : { *(.keep) } /*" >> %t.script
 # RUN: echo "comment line 1" >> %t.script
 # RUN: echo "comment line 2 */" >> %t.script
 # RUN: echo ".temp + { *(.temp) } }" >> %t.script
 # RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | FileCheck -check-prefix=ERR5 %s
-# ERR5: line 6:
+# ERR5: {{.*}}.script:6:
 
 ## Check that text of lines and pointer to 'bad' token are working ok.
 # RUN: echo "UNKNOWN_TAG {" > %t.script
 # RUN: echo ".text : { *(.text) }" >> %t.script
 # RUN: echo ".keep : { *(.keep) }" >> %t.script
 # RUN: echo ".temp : { *(.temp) } }" >> %t.script
 # RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERR6 -strict-whitespace %s
-# ERR6:      error: line 1:
-# ERR6-NEXT: error: UNKNOWN_TAG {
-# ERR6-NEXT: error: ^
+# ERR6:      error: {{.*}}.script:1:
+# ERR6-NEXT: error: {{.*}}.script:1: UNKNOWN_TAG {
+# ERR6-NEXT: error: {{.*}}.script:1: ^
 
 ## One more check that text of lines and pointer to 'bad' token are working ok.
 # RUN: echo "SECTIONS {" > %t.script
 # RUN: echo ".text : { *(.text) }" >> %t.script
 # RUN: echo ".keep : { *(.keep) }" >> %t.script
 # RUN: echo "boom .temp : { *(.temp) } }" >> %t.script
 # RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERR7 -strict-whitespace %s
-# ERR7:      error: line 4: malformed number: .temp
-# ERR7-NEXT: error: boom .temp : { *(.temp) } }
-# ERR7-NEXT: error:      ^
+# ERR7:      error: {{.*}}.script:4: malformed number: .temp
+# ERR7-NEXT: error: {{.*}}.script:4: boom .temp : { *(.temp) } }
+# ERR7-NEXT: error: {{.*}}.script:4:      ^
+
+## Check tokenize() error
+# RUN: echo "SECTIONS {}" > %t.script
+# RUN: echo "\"" >> %t.script
+# RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR8 -strict-whitespace %s
+# ERR8: {{.*}}.script:2: unclosed quote
+
+## Check tokenize() error in included script file
+# RUN: echo "SECTIONS {}" > %t.script.inc
+# RUN: echo "\"" >> %t.script.inc
+# RUN: echo "INCLUDE \"%t.script.inc\"" > %t.script
+# RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR9 -strict-whitespace %s
+# ERR9: {{.*}}.script.inc:2: unclosed quote
+
+## Check error reporting correctness for included files.
+# RUN: echo "SECTIONS {" > %t.script.inc
+# RUN: echo ".text : { *(.text) }" >> %t.script.inc
+# RUN: echo ".keep : { *(.keep) }" >> %t.script.inc
+# RUN: echo "boom .temp : { *(.temp) } }" >> %t.script.inc
+# RUN: echo "INCLUDE \"%t.script.inc\"" > %t.script
+# RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR10 -strict-whitespace %s
+# ERR10:      error: {{.*}}.script.inc:4: malformed number: .temp
+# ERR10-NEXT: error: {{.*}}.script.inc:4: boom .temp : { *(.temp) } }
+# ERR10-NEXT: error: {{.*}}.script.inc:4:      ^
+
+## Check error reporting in script with INCLUDE directive.
+# RUN: echo "SECTIONS {" > %t.script.inc
+# RUN: echo ".text : { *(.text) }" >> %t.script.inc
+# RUN: echo ".keep : { *(.keep) }" >> %t.script.inc
+# RUN: echo ".temp : { *(.temp) } }" >> %t.script.inc
+# RUN: echo "/* One line before INCLUDE */" > %t.script
+# RUN: echo "INCLUDE \"%t.script.inc\"" >> %t.script
+# RUN: echo "/* One line ater INCLUDE */" >> %t.script
+# RUN: echo "Error" >> %t.script
+# RUN: not ld.lld -shared %t -o %t1 --script %t.script 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR11 -strict-whitespace %s
+# ERR11: error: {{.*}}.script:4: unexpected EOF

test/ELF/version-script-err.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: not ld.lld -shared %t.o -o %t.so --version-script %p/Inputs/version-script-err.script 2>&1 | FileCheck %s
 // CHECK: ; expected, but got }
 
 // RUN: echo    "\"" > %terr1.script
 // RUN: not ld.lld --version-script %terr1.script -shared %t.o -o %t.so 2>&1 | \
 // RUN:   FileCheck -check-prefix=ERR1 %s
-// ERR1: unclosed quote
+// ERR1: {{.*}}:1: unclosed quote
+// ERR1-NEXT: {{.*}}: unexpected EOF