[ELF] Remove {ELF,}GNULinkerScript InputElements.

[ruiu]

Summary

Instead of representing a linker script file as an "InputElement",
parse and evaluate scripts in the driver as we see them.

Linker scripts are not regular input files (regular file is one of
object, archive, or shared library file). They are more like
extended command line options. Linker script handling was needlessly
complicated because of that inappropriate abstraction (besides
excessive class hierarchy -- there is no such thing like ELF linker
script but we had two classes there for some reason.)

LinkerScript was one of a few remaining InputElement subclasses
that can be expanded to multiple files. With this patch, we are one
step closer to retire InputElement.

[• shankar.easwaran]

It's best for the linker script to be handled through the registry.

[ruiu]

No it's not. We could have handled a linker script using the Registry, but
it wouldn't fit well because the Registry is a mechanism to convert a file
to a File object. We could have generalized the Registry to cover the
linker script, but this is exactly what we are trying to eliminate right
now (an excessive abstraction).

Another (obvious) counter example is response file. This should naturally
be handled by the Driver. What this example means is that being an external
file doesn't always mean that the file should be handled through the
Registry mechanism.

[• shankar.easwaran]

We are trying to duplicate getfilemagic in the driver which is actually part of the registry. The linker script should not be parsed in the driver immediately. The whole reason why the linker script is being parsed in the driver is we don't have a way to handle a script when the linker script is specified just like any other input file or library in the parser or registry. It should be parsed late whenever we figure out that the file is a linker script. We should parse more input files by using a lazy parsing method using file locator.

Bigcheese / Nick ?

[Eugene.Zelenko]

Committed in r225330.

include/lld/Driver/GnuLdInputGraph.h

 
 #ifndef LLD_DRIVER_GNU_LD_INPUT_GRAPH_H
 #define LLD_DRIVER_GNU_LD_INPUT_GRAPH_H
 
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/InputGraph.h"
 #include "lld/Core/Resolver.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "lld/ReaderWriter/LinkerScript.h"
 
 namespace lld {
 
 /// \brief Represents a ELF File
 class ELFFileNode : public FileNode {
 public:
   /// \brief The attributes class provides a way for a input file to look into
   /// all the positional attributes that were specified in the command line.

 
 private:
   llvm::BumpPtrAllocator _alloc;
   const ELFLinkingContext &_elfLinkingContext;
   std::unique_ptr<const ArchiveLibraryFile> _archiveFile;
   const Attributes _attributes;
 };
 
-/// \brief Parse GNU Linker scripts.
-class GNULdScript : public FileNode {
-public:
-  GNULdScript(ELFLinkingContext &ctx, StringRef userPath)
-      : FileNode(userPath), _elfLinkingContext(ctx), _linkerScript(nullptr) {}
-
-  /// \brief Parse the linker script.
-  std::error_code parse(const LinkingContext &, raw_ostream &) override;
-
-protected:
-  ELFLinkingContext &_elfLinkingContext;
-  std::unique_ptr<script::Parser> _parser;
-  std::unique_ptr<script::Lexer> _lexer;
-  script::LinkerScript *_linkerScript;
-};
-
-/// \brief Handle ELF style with GNU Linker scripts.
-class ELFGNULdScript : public GNULdScript {
-public:
-  ELFGNULdScript(ELFLinkingContext &ctx, StringRef userPath)
-      : GNULdScript(ctx, userPath) {}
-
-  std::error_code parse(const LinkingContext &ctx,
-                        raw_ostream &diagnostics) override;
-
-  bool getReplacements(InputGraph::InputElementVectorT &result) override {
-    for (std::unique_ptr<InputElement> &elt : _expandElements)
-      result.push_back(std::move(elt));
-    return true;
-  }
-
-  /// Unused functions for ELFGNULdScript Nodes.
-  ErrorOr<File &> getNextFile() override {
-    return make_error_code(InputGraphError::no_more_files);
-  }
-
-  // Linker Script will be expanded and replaced with other elements
-  // by InputGraph::normalize(), so at link time it does not exist in
-  // the tree. No need to handle this message.
-  void resetNextIndex() override {}
-
-private:
-  InputGraph::InputElementVectorT _expandElements;
-};
-
 } // namespace lld
 
 #endif

lib/Driver/GnuLdDriver.cpp

 /// \file
 ///
 /// Concrete instance of the Driver for GNU's ld.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lld/Driver/Driver.h"
 #include "lld/Driver/GnuLdInputGraph.h"
+#include "lld/ReaderWriter/LinkerScript.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
static bool isLinkerScript(StringRef path, raw_ostream &diag) {
   std::error_code ec = getFileMagic(path, magic);
   if (ec) {
     diag << "unknown input file format for file " << path << "\n";
     return false;
   }
   return magic == llvm::sys::fs::file_magic::unknown;
 }
 
+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
+evaluateLinkerScript(ELFLinkingContext &ctx, InputGraph *inputGraph,
+                     StringRef path, raw_ostream &diag) {
+  // Read the script file from disk and parse.
+  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
+      MemoryBuffer::getFileOrSTDIN(path);
+  if (std::error_code ec = mb.getError())
+    return ec;
+  if (ctx.logInputFiles())
+    diag << path << "\n";
+  auto lexer = llvm::make_unique<script::Lexer>(std::move(mb.get()));
+  auto parser = llvm::make_unique<script::Parser>(*lexer);
+  script::LinkerScript *script = parser->parse();
+  if (!script)
+    return LinkerScriptReaderError::parse_error;
+
+  // Evaluate script commands.
+  // Currently we only recognize GROUP() command.
+  bool sysroot = (!ctx.getSysroot().empty()
+                  && isPathUnderSysroot(ctx.getSysroot(), path));
+  for (const script::Command *c : script->_commands) {
+    auto *group = dyn_cast<script::Group>(c);
+    if (!group)
+      continue;
+    int numfiles = 0;
+    for (const script::Path &path : group->getPaths()) {
+      // TODO : Propagate Set WholeArchive/dashlPrefix
+      ELFFileNode::Attributes attr;
+      attr.setSysRooted(sysroot);
+      attr.setAsNeeded(path._asNeeded);
+      attr.setDashlPrefix(path._isDashlPrefix);
+      ++numfiles;
+      inputGraph->addInputElement(llvm::make_unique<ELFFileNode>(
+                                      ctx, ctx.allocateString(path._path), attr));
+    }
+    inputGraph->addInputElement(llvm::make_unique<GroupEnd>(numfiles));
+  }
+  return std::error_code();
+}
+
 bool GnuLdDriver::applyEmulation(llvm::Triple &triple,
                                  llvm::opt::InputArgList &args,
                                  raw_ostream &diagnostics) {
   llvm::opt::Arg *arg = args.getLastArg(OPT_m);
   if (!arg)
     return true;
   llvm::Optional<llvm::Triple::ArchType> arch =
       getArchType(triple, arg->getValue());
case OPT_l: {
         realpath = pathOrErr->str();
       }
       if (!llvm::sys::fs::exists(realpath)) {
         diagnostics << "lld: cannot find file " << path << "\n";
         return false;
       }
       bool isScript =
           (!path.endswith(".objtxt") && isLinkerScript(realpath, diagnostics));
-      FileNode *inputNode = nullptr;
       if (isScript) {
-        inputNode = new ELFGNULdScript(*ctx, realpath);
-        if (inputNode->parse(*ctx, diagnostics)) {
-          diagnostics << path << ": Error parsing linker script\n";
+        std::error_code ec = evaluateLinkerScript(
+            *ctx, inputGraph.get(), realpath, diagnostics);
+        if (ec) {
+          diagnostics << path << ": Error parsing linker script: "
+                      << ec.message() << "\n";
           return false;
         }
-      } else {
-        inputNode = new ELFFileNode(*ctx, path, attributes);
+        break;
       }
-      std::unique_ptr<InputElement> inputFile(inputNode);
       ++numfiles;
-      inputGraph->addInputElement(std::move(inputFile));
+      inputGraph->addInputElement(
+          llvm::make_unique<ELFFileNode>(*ctx, path, attributes));
       break;
     }
 
     case OPT_rpath: {
       SmallVector<StringRef, 2> rpaths;
       StringRef(inputArg->getValue()).split(rpaths, ":");
       for (auto path : rpaths)
         ctx->addRpath(path);

lib/Driver/GnuLdInputGraph.cpp

if (const auto *archive = dyn_cast<ArchiveLibraryFile>(f.get())) {
       return archive->parseAllMembers(_files);
     }
     // if --whole-archive is around non-archive, just use it as normal.
     _files.push_back(std::move(f));
     return std::error_code();
   }
   return ctx.registry().parseFile(std::move(mb.get()), _files);
 }
-
-/// \brief Parse the GnuLD Script
-std::error_code GNULdScript::parse(const LinkingContext &ctx,
-                                   raw_ostream &diagnostics) {
-  ErrorOr<StringRef> filePath = getPath(ctx);
-  if (std::error_code ec = filePath.getError())
-    return ec;
-  ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
-      MemoryBuffer::getFileOrSTDIN(*filePath);
-  if (std::error_code ec = mb.getError())
-    return ec;
-
-  if (ctx.logInputFiles())
-    diagnostics << *filePath << "\n";
-
-  _lexer.reset(new script::Lexer(std::move(mb.get())));
-  _parser.reset(new script::Parser(*_lexer.get()));
-
-  _linkerScript = _parser->parse();
-
-  if (!_linkerScript)
-    return LinkerScriptReaderError::parse_error;
-
-  return std::error_code();
-}
-
-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();
-}
-
-/// \brief Handle GnuLD script for ELF.
-std::error_code ELFGNULdScript::parse(const LinkingContext &ctx,
-                                      raw_ostream &diagnostics) {
-  ELFFileNode::Attributes attributes;
-  if (std::error_code ec = GNULdScript::parse(ctx, diagnostics))
-    return ec;
-  StringRef sysRoot = _elfLinkingContext.getSysroot();
-  if (!sysRoot.empty() && isPathUnderSysroot(sysRoot, *getPath(ctx)))
-    attributes.setSysRooted(true);
-  for (const script::Command *c : _linkerScript->_commands) {
-    auto *group = dyn_cast<script::Group>(c);
-    if (!group)
-      continue;
-    size_t numfiles = 0;
-    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);
-      _expandElements.push_back(std::move(inputFile));
-      ++numfiles;
-    }
-    _expandElements.push_back(llvm::make_unique<GroupEnd>(numfiles));
-  }
-  return std::error_code();
-}