[ELF] Implement parsing `-l` prefixed items in the `GROUP` linker script command

[atanasyan]

Summary

Implement parsing -l prefixed items in the GROUP linker script command. There are two forms of -l prefixed expression:

• -l<libname>
• -l:<filename>

In the first case a linker should construct a full library name lib + libname + .[so|a] and search this library as usual. In the second case a linker should use the <filename> as is and search this file through library search directories.

[shankarke]

include/lld/ReaderWriter/LinkerScript.h

76

Should this be a ErrorOr<StringRef::size_type> ?

76

const.

76

Do we have a test that covers the error case ?

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

169

aName=> archiveName ?

lib/ReaderWriter/LinkerScript.cpp

127

raise an error here.

210

I think we need canStartLibraryName, as canStartName returns true for cases where a library name would be invalid.

For example the below cases.

case '_': case '.': case '$': case '/': case '\\':
  return true;

We should reject invalid library names IMO

216

error here ?

[atanasyan]

• Fixed all minor problems line const qualifiers, local variable naming etc.
• Made the code which handles a library name -l shorter and more similar to the code handles a regular file names.
• Keep using the unknown token to indicate an unexpected input. The same approach is used by other parts of the lexer now.
• Added some new test cases.
• I decided to do not introduce new routines like canStartLibraryName to validate library names. Anyway we check this name later and report an error if this name is invalid. It is better than reject a valid name here by mistake. By the way BFD and Gold linker accept almost arbitrary names.

[atanasyan]

Thanks for review.

Closed by commit rL213077.

include/lld/ReaderWriter/LinkerScript.h

 namespace lld {
 namespace script {
 class Token {
 public:
   enum Kind {
     unknown,
     eof,
     identifier,
+    libname,
     comma,
     l_paren,
     r_paren,
     kw_entry,
     kw_group,
     kw_output_format,
     kw_output_arch,
     kw_as_needed

 private:
   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;
 };
 
 class Command {
 public:
   enum class Kind { Entry, OutputFormat, OutputArch, Group, };
 
   Kind getKind() const { return _kind; }

 
 private:
   StringRef _arch;
 };
 
 struct Path {
   StringRef _path;
   bool _asNeeded;
+  bool _isDashlPrefix;
 
-  Path() : _asNeeded(false) {}
-  explicit Path(StringRef path, bool asNeeded = false)
-      : _path(path), _asNeeded(asNeeded) {}
+  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) {
     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;
     for (const Path &path : getPaths()) {
       if (!first)
         os << " ";
       first = false;
       if (path._asNeeded)
         os << "AS_NEEDED(";
+      if (path._isDashlPrefix)
+        os << "-l";
       os << path._path;
       if (path._asNeeded)
         os << ")";
     }
     os << ")\n";
   }
 
   const std::vector<Path> &getPaths() const { return _paths; }

lib/Driver/GnuLdInputGraph.cpp

std::error_code ELFGNULdScript::parse(const LinkingContext &ctx,
   for (const script::Command *c : _linkerScript->_commands) {
     auto *group = dyn_cast<script::Group>(c);
     if (!group)
       continue;
     std::unique_ptr<Group> groupStart(new Group());
     for (const script::Path &path : group->getPaths()) {
       // TODO : Propagate Set WholeArchive/dashlPrefix
       attributes.setAsNeeded(path._asNeeded);
+      attributes.setDashlPrefix(path._isDashlPrefix);
       auto inputNode = new ELFFileNode(
           _elfLinkingContext, _elfLinkingContext.allocateString(path._path),
           attributes);
       std::unique_ptr<InputElement> inputFile(inputNode);
       groupStart.get()->addFile(std::move(inputFile));
     }
     _expandElements.push_back(std::move(groupStart));
   }
   return std::error_code();
 }

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

if (!dir.startswith("=/"))
     path.assign(dir);
   else {
     path.assign(sysRoot);
     path.append(dir.substr(1));
   }
 }
 
 ErrorOr<StringRef> ELFLinkingContext::searchLibrary(StringRef libName) const {
+  bool hasColonPrefix = libName[0] == ':';
+  Twine soName =
+      hasColonPrefix ? libName.drop_front() : Twine("lib", libName) + ".so";
+  Twine archiveName =
+      hasColonPrefix ? libName.drop_front() : Twine("lib", libName) + ".a";
   SmallString<128> path;
   for (StringRef dir : _inputSearchPaths) {
     // Search for dynamic library
     if (!_isStaticExecutable) {
       buildSearchPath(path, dir, _sysrootPath);
-      llvm::sys::path::append(path, Twine("lib") + libName + ".so");
+      llvm::sys::path::append(path, soName);
       if (llvm::sys::fs::exists(path.str()))
         return StringRef(*new (_allocator) std::string(path.str()));
     }
     // Search for static libraries too
     buildSearchPath(path, dir, _sysrootPath);
-    llvm::sys::path::append(path, Twine("lib") + libName + ".a");
+    llvm::sys::path::append(path, archiveName);
     if (llvm::sys::fs::exists(path.str()))
       return StringRef(*new (_allocator) std::string(path.str()));
   }
   if (!llvm::sys::fs::exists(libName))
     return make_error_code(llvm::errc::no_such_file_or_directory);
 
   return libName;
 }

lib/ReaderWriter/LinkerScript.cpp

 void Token::dump(raw_ostream &os) const {
   switch (_kind) {
 #define CASE(name)                              \
   case Token::name:                             \
     os << #name ": ";                           \
     break;
   CASE(eof)
   CASE(identifier)
+  CASE(libname)
   CASE(kw_as_needed)
   CASE(kw_entry)
   CASE(kw_group)
   CASE(kw_output_format)
   CASE(kw_output_arch)
   CASE(comma)
   CASE(l_paren)
   CASE(r_paren)
if ((_buffer[0] == '\"') || (_buffer[0] == '\'')) {
       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);
       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(),
+                       [=](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]))
       break;
     auto endIter =
         std::find_if(_buffer.begin() + 1, _buffer.end(), [=](char c) {
       return !canContinueName(c);
     });
     StringRef::size_type end =
void Lexer::skipWhitespace() {
   }
 }
 
 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::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);

 Group *Parser::parseGroup() {
   assert(_tok._kind == Token::kw_group && "Expected GROUP!");
   consumeToken();
   if (!expectAndConsume(Token::l_paren, "expected ("))
     return nullptr;
 
   std::vector<Path> paths;
 
-  while (_tok._kind == Token::identifier || _tok._kind == Token::kw_as_needed) {
+  while (_tok._kind == Token::identifier || _tok._kind == Token::libname ||
+         _tok._kind == Token::kw_as_needed) {
     switch (_tok._kind) {
     case Token::identifier:
       paths.push_back(Path(_tok._range));
       consumeToken();
       break;
+    case Token::libname:
+      paths.push_back(Path(_tok._range, false, true));
+      consumeToken();
+      break;
     case Token::kw_as_needed:
       if (!parseAsNeeded(paths))
         return nullptr;
       break;
     default:
       llvm_unreachable("Invalid token.");
     }
   }
 
   auto ret = new (_alloc) Group(paths);
 
   if (!expectAndConsume(Token::r_paren, "expected )"))
     return nullptr;
 
   return ret;
 }
 
 // Parse AS_NEEDED(file ...)
 bool Parser::parseAsNeeded(std::vector<Path> &paths) {
   assert(_tok._kind == Token::kw_as_needed && "Expected AS_NEEDED!");
   consumeToken();
   if (!expectAndConsume(Token::l_paren, "expected ("))
     return false;
 
-  while (_tok._kind == Token::identifier) {
-    paths.push_back(Path(_tok._range, true));
+  while (_tok._kind == Token::identifier || _tok._kind == Token::libname) {
+    switch (_tok._kind) {
+    case Token::identifier:
+      paths.push_back(Path(_tok._range, true, false));
       consumeToken();
+      break;
+    case Token::libname:
+      paths.push_back(Path(_tok._range, true, true));
+      consumeToken();
+      break;
+    default:
+      llvm_unreachable("Invalid token.");
+    }
   }
 
   if (!expectAndConsume(Token::r_paren, "expected )"))
     return false;
   return true;
 }
 
 // Parse ENTRY(ident)

test/LinkerScript/libname-err-1.test

+/* RUN: linker-script-test %s 2>&1 | FileCheck %s
+*/
+
+OUTPUT_ARCH(i386:x86_64)
+OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
+GROUP( -l### )
+ENTRY(init)
+
+/*
+CHECK: test/LinkerScript/libname-err-1.test:6:10: error: expected )
+*/

test/LinkerScript/libname-err-2.test

+/* RUN: linker-script-test %s 2>&1 | FileCheck %s
+*/
+
+OUTPUT_ARCH(i386:x86_64)
+OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
+GROUP( -l )
+ENTRY(init)
+
+/*
+CHECK: test/LinkerScript/libname-err-2.test:6:10: error: expected )
+*/

test/LinkerScript/linker-script.test

 /* RUN: linker-script-test %s | FileCheck %s
 */
 
 OUTPUT_ARCH(i386:x86_64)
 OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
-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 ) )
+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 )
 ENTRY(init)
 
 /*
 CHECK: kw_output_arch: OUTPUT_ARCH
 CHECK: l_paren: (
 CHECK: identifier: i386:x86_64
 CHECK: r_paren: )
 CHECK: kw_output_format: OUTPUT_FORMAT
 CHECK: l_paren: (
 CHECK: identifier: elf64-x86-64
 CHECK: comma: ,
 CHECK: identifier: elf64-x86-64
 CHECK: comma: ,
 CHECK: identifier: elf64-x86-64
 CHECK: r_paren: )
 CHECK: kw_group: GROUP
 CHECK: l_paren: (
 CHECK: identifier: /lib/x86_64-linux-gnu/libc.so.6
 CHECK: identifier: /usr/lib/x86_64-linux-gnu/libc_nonshared.a
 CHECK: kw_as_needed: AS_NEEDED
 CHECK: l_paren: (
 CHECK: identifier: /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
 CHECK: r_paren: )
+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: 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))
+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/elf/Inputs/group-cmd-search-3.ls

+GROUP ( -l:shared.so-x86-64 -lfnarchive )

test/elf/group-cmd-search.test

/*
   under the sysroot directory.
 
 RUN: lld -flavor gnu -target x86_64 -shared --sysroot=%p/Inputs/../Inputs \
 RUN:     -L%p/Inputs %p/Inputs/use-shared.x86-64 \
 RUN:     %p/Inputs/group-cmd-search-2.ls -o %t6
 */
 
 /*
+  This link should finish successfully. The group-cmd-search-3.ls
+  script contains GROUP command with two elements. The first one
+  has a -l:<path> form and should be found by iterating through
+  lib dirs and searching the 'path' name exactly. The second element
+  has a -l<lib name> form and should be found by constructing a full
+  library name lib<lib name>.a and iterating through lib dirs.
+
+RUN: lld -flavor gnu -target x86_64 -shared \
+RUN:     -L%p/Inputs %p/Inputs/use-shared.x86-64 \
+RUN:     %p/Inputs/group-cmd-search-3.ls -o %t8
+*/
+
+/*
   This link should fail with unknown input file format error.
   The linker script from this file contains GROUP with an absolute
   path which can be found under provided sysroot directory.
   But the linker script itself is not under the sysroot.
 
 RUN: not \
 RUN: lld -flavor gnu -target x86_64 -shared --sysroot=%p/Inputs \
 RUN:     -L%p/Inputs %p/Inputs/use-shared.x86-64 \
 RUN:     %s -o %t7
 */
 GROUP ( /shared.so-x86-64 )