ELF: Support INPUT linker script directive

[ruiu]

Summary

INPUT directive is a variant of GROUP in the sense that that specifies
a list of input files. The only difference is whether the entire file
list is wrapped with a --start-group/--end-group or not.

[rafaelauler]

LGTM

[Eugene.Zelenko]

Committed in r228060.

include/lld/ReaderWriter/LinkerScript.h

enum Kind {
     kw_align_with_input,
     kw_as_needed,
     kw_at,
     kw_discard,
     kw_entry,
     kw_exclude_file,
     kw_group,
     kw_hidden,
+    kw_input,
     kw_keep,
     kw_provide,
     kw_provide_hidden,
     kw_only_if_ro,
     kw_only_if_rw,
     kw_output,
     kw_output_arch,
     kw_output_format,

 ///              }
 ///  }
 ///
 class Command {
 public:
   enum class Kind {
     Entry,
     Group,
+    Input,
     InputSectionsCmd,
     Output,
     OutputArch,
     OutputFormat,
     OutputSectionDescription,
     Overlay,
     SearchDir,
     Sections,
struct 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 {
+template<Command::Kind K>
+class PathList : public Command {
 public:
-  template <class RangeT> explicit Group(RangeT range) : Command(Kind::Group) {
+  template <class RangeT> PathList(StringRef name, RangeT range)
+      : Command(K), _name(name) {
     std::copy(std::begin(range), std::end(range), std::back_inserter(_paths));
   }
 
-  static bool classof(const Command *c) { return c->getKind() == Kind::Group; }
+  static bool classof(const Command *c) { return c->getKind() == K; }
 
   void dump(raw_ostream &os) const override {
-    os << "GROUP(";
+    os << _name << "(";
     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; }
 
 private:
+  StringRef _name;
   std::vector<Path> _paths;
 };
 
+class Group : public PathList<Command::Kind::Group> {
+public:
+  template <class RangeT> Group(RangeT range)
+      : PathList("GROUP", std::move(range)) {}
+};
+
+class Input : public PathList<Command::Kind::Input> {
+public:
+  template <class RangeT> Input(RangeT range)
+      : PathList("INPUT", std::move(range)) {}
+};
+
 class Entry : public Command {
 public:
   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 {
private:
   /// Parse the OUTPUT_ARCH linker script command.
   /// Example:
   ///
   /// OUTPUT_ARCH(i386:x86-64)
   /// ^~~~> parseOutputArch()
   ///
   OutputArch *parseOutputArch();
 
-  /// Parse the GROUP linker script command.
+  /// Parse the INPUT or 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();
+  template<class T> T *parsePathList();
   bool parseAsNeeded(std::vector<Path> &paths);
 
   /// Parse the ENTRY linker script command.
   /// Example:
   ///
   /// ENTRY(init)
   /// ^~~~> parseEntry()
   ///

lib/Driver/GnuLdDriver.cpp

static bool isPathUnderSysroot(StringRef sysroot, StringRef path) {
   if (sysroot.empty())
     return false;
   while (!path.empty() && !llvm::sys::fs::equivalent(sysroot, path))
     path = llvm::sys::path::parent_path(path);
   return !path.empty();
 }
 
 static std::error_code
-evaluateLinkerScriptGroup(ELFLinkingContext &ctx, StringRef path,
-                          const script::Group *group, raw_ostream &diag) {
+addFilesFromLinkerScript(ELFLinkingContext &ctx, StringRef scriptPath,
+                         const std::vector<script::Path> &inputPaths,
+                         raw_ostream &diag) {
   bool sysroot = (!ctx.getSysroot().empty()
-                  && isPathUnderSysroot(ctx.getSysroot(), path));
-  int numfiles = 0;
-  for (const script::Path &path : group->getPaths()) {
+                  && isPathUnderSysroot(ctx.getSysroot(), scriptPath));
+  for (const script::Path &path : inputPaths) {
     ErrorOr<StringRef> pathOrErr = path._isDashlPrefix
       ? ctx.searchLibrary(path._path) : ctx.searchFile(path._path, sysroot);
     if (std::error_code ec = pathOrErr.getError()) {
       auto file = llvm::make_unique<ErrorFile>(path._path, ec);
       ctx.getNodes().push_back(llvm::make_unique<FileNode>(std::move(file)));
-      ++numfiles;
       continue;
     }
 
     std::vector<std::unique_ptr<File>> files
       = loadFile(ctx, pathOrErr.get(), false);
     for (std::unique_ptr<File> &file : files) {
       if (ctx.logInputFiles())
         diag << file->path() << "\n";
       ctx.getNodes().push_back(llvm::make_unique<FileNode>(std::move(file)));
-      ++numfiles;
     }
   }
-  ctx.getNodes().push_back(llvm::make_unique<GroupEnd>(numfiles));
   return std::error_code();
 }
 
 std::error_code
 GnuLdDriver::evalLinkerScript(ELFLinkingContext &ctx,
                               std::unique_ptr<MemoryBuffer> mb,
                               raw_ostream &diag) {
   // Read the script file from disk and parse.
   StringRef path = mb->getBufferIdentifier();
   auto parser = llvm::make_unique<script::Parser>(std::move(mb));
   if (std::error_code ec = parser->parse())
     return ec;
   script::LinkerScript *script = parser->get();
   if (!script)
     return LinkerScriptReaderError::parse_error;
   // Evaluate script commands.
   // Currently we only recognize this subset of linker script commands.
   for (const script::Command *c : script->_commands) {
-    if (auto *group = dyn_cast<script::Group>(c))
-      if (std::error_code ec = evaluateLinkerScriptGroup(ctx, path, group, diag))
+    if (auto *input = dyn_cast<script::Input>(c))
+      if (std::error_code ec = addFilesFromLinkerScript(
+            ctx, path, input->getPaths(), diag))
         return ec;
+    if (auto *group = dyn_cast<script::Group>(c)) {
+      int origSize = ctx.getNodes().size();
+      if (std::error_code ec = addFilesFromLinkerScript(
+            ctx, path, group->getPaths(), diag))
+        return ec;
+      size_t groupSize = ctx.getNodes().size() - origSize;
+      ctx.getNodes().push_back(llvm::make_unique<GroupEnd>(groupSize));
+    }
     if (auto *searchDir = dyn_cast<script::SearchDir>(c))
       ctx.addSearchPath(searchDir->getSearchPath());
     if (auto *entry = dyn_cast<script::Entry>(c))
       ctx.setEntrySymbolName(entry->getEntryName());
     if (auto *output = dyn_cast<script::Output>(c))
       ctx.setOutputPath(output->getOutputFileName());
   }
   // Transfer ownership of the script to the linking context

lib/ReaderWriter/LinkerScript.cpp

case Token::name:                                                            \
     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_hidden)
+    CASE(kw_input)
     CASE(kw_keep)
     CASE(kw_provide)
     CASE(kw_provide_hidden)
     CASE(kw_only_if_ro)
     CASE(kw_only_if_rw)
     CASE(kw_output)
     CASE(kw_output_arch)
     CASE(kw_output_format)
Token::Kind kind =
             .Case("ALIGN", Token::kw_align)
             .Case("ALIGN_WITH_INPUT", Token::kw_align_with_input)
             .Case("AS_NEEDED", Token::kw_as_needed)
             .Case("AT", Token::kw_at)
             .Case("ENTRY", Token::kw_entry)
             .Case("EXCLUDE_FILE", Token::kw_exclude_file)
             .Case("GROUP", Token::kw_group)
             .Case("HIDDEN", Token::kw_hidden)
+            .Case("INPUT", Token::kw_input)
             .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", Token::kw_output)
             .Case("OUTPUT_ARCH", Token::kw_output_arch)
             .Case("OUTPUT_FORMAT", Token::kw_output_format)
             .Case("OVERLAY", Token::kw_overlay)
             .Case("PROVIDE", Token::kw_provide)
while (true) {
     }
     case Token::kw_output_arch: {
       auto outputArch = parseOutputArch();
       if (!outputArch)
         return LinkerScriptReaderError::parse_error;
       _script._commands.push_back(outputArch);
       break;
     }
+    case Token::kw_input: {
+      Input *input = parsePathList<Input>();
+      if (!input)
+        return LinkerScriptReaderError::parse_error;
+      _script._commands.push_back(input);
+      break;
+    }
     case Token::kw_group: {
-      auto group = parseGroup();
+      Group *group = parsePathList<Group>();
       if (!group)
         return LinkerScriptReaderError::parse_error;
       _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.");
OutputArch *Parser::parseOutputArch() {
   consumeToken();
 
   if (!expectAndConsume(Token::r_paren, "expected )"))
     return nullptr;
 
   return ret;
 }
 
-// Parse GROUP(file ...)
-Group *Parser::parseGroup() {
-  assert(_tok._kind == Token::kw_group && "Expected GROUP!");
+// Parse file list for INPUT or GROUP
+template<class T> T *Parser::parsePathList() {
   consumeToken();
   if (!expectAndConsume(Token::l_paren, "expected ("))
     return nullptr;
 
   std::vector<Path> paths;
-
   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;
+  return new (_alloc) T(paths);
 }
 
 // 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;

unittests/DriverTests/GnuLdDriverTest.cpp

TEST_F(GnuLdParserTest, AsNeeded) {
   EXPECT_FALSE(cast<FileNode>(nodes[0].get())->asNeeded());
   EXPECT_TRUE(cast<FileNode>(nodes[1].get())->asNeeded());
   EXPECT_TRUE(cast<FileNode>(nodes[2].get())->asNeeded());
   EXPECT_FALSE(cast<FileNode>(nodes[3].get())->asNeeded());
 }
 
 // Linker script
 
+TEST_F(LinkerScriptTest, Input) {
+  parse("INPUT(/x /y)");
+  std::vector<std::unique_ptr<Node>> &nodes = _ctx->getNodes();
+  EXPECT_EQ((size_t)2, nodes.size());
+  EXPECT_EQ("/x", cast<FileNode>(nodes[0].get())->getFile()->path());
+  EXPECT_EQ("/y", cast<FileNode>(nodes[1].get())->getFile()->path());
+}
+
 TEST_F(LinkerScriptTest, Group) {
   parse("GROUP(/x /y)");
   std::vector<std::unique_ptr<Node>> &nodes = _ctx->getNodes();
   EXPECT_EQ((size_t)3, nodes.size());
   EXPECT_EQ("/x", cast<FileNode>(nodes[0].get())->getFile()->path());
   EXPECT_EQ("/y", cast<FileNode>(nodes[1].get())->getFile()->path());
   EXPECT_EQ(2, cast<GroupEnd>(nodes[2].get())->getSize());
 }