Merge ELFGroup with Group.

[ruiu]

Summary

Group class is designed for GNU LD's --start-group and --end-group. There's
no obvious need to have two classes for it -- one as an abstract base class
and the other as the only derived class of it. They can simply be merged.

[Bigcheese]

lgtm.

[Eugene.Zelenko]

Committed in r205375.

include/lld/Core/InputGraph.h

public:
   }
 
   void resetNextIndex() override {
     _currentElementIndex = _nextElementIndex = 0;
     for (auto &elem : _elements)
       elem->resetNextIndex();
   }
 
+  /// \brief Parse the group members.
+  error_code parse(const LinkingContext &ctx, raw_ostream &diag) override {
+    for (auto &ei : _elements)
+      if (error_code ec = ei->parse(ctx, diag))
+        return ec;
+    return error_code::success();
+  }
+
   uint32_t getResolveState() const override;
   void setResolveState(uint32_t) override;
   ErrorOr<File &> getNextFile() override;
 
 protected:
   InputGraph::InputElementVectorT _elements;
   uint32_t _currentElementIndex;
   uint32_t _nextElementIndex;

include/lld/Driver/GnuLdInputGraph.h

private:
   llvm::BumpPtrAllocator _alloc;
   const ELFLinkingContext &_elfLinkingContext;
   bool _isWholeArchive;
   bool _asNeeded;
   bool _isDashlPrefix;
   std::unique_ptr<const ArchiveLibraryFile> _archiveFile;
 };
 
-/// \brief Represents a ELF control node
-class ELFGroup : public Group {
-public:
-  ELFGroup(const ELFLinkingContext &, int64_t ordinal)
-      : Group(ordinal) {}
-
-  /// \brief Parse the group members.
-  error_code parse(const LinkingContext &ctx, raw_ostream &diagnostics) override {
-    for (auto &ei : _elements)
-      if (error_code ec = ei->parse(ctx, diagnostics))
-        return ec;
-    return error_code::success();
-  }
-};
-
 /// \brief Parse GNU Linker scripts.
 class GNULdScript : public FileNode {
 public:
   GNULdScript(ELFLinkingContext &ctx, StringRef userPath, int64_t ordinal)
       : FileNode(userPath, ordinal), _elfLinkingContext(ctx),
         _linkerScript(nullptr) {}
 
   /// \brief Parse the linker script.

include/lld/Driver/WinLinkInputGraph.h

 };
 
 /// \brief Represents a ELF control node
 class PECOFFGroup : public Group {
 public:
   PECOFFGroup(PECOFFLinkingContext &ctx) : Group(0), _ctx(ctx) {}
 
   /// \brief Parse the group members.
-  error_code parse(const LinkingContext &ctx, raw_ostream &diagnostics) override {
+  error_code parse(const LinkingContext &ctx, raw_ostream &diag) override {
     std::lock_guard<std::recursive_mutex> lock(_ctx.getMutex());
-    for (auto &elem : _elements)
-      if (error_code ec = elem->parse(ctx, diagnostics))
-        return ec;
-    return error_code::success();
+    return Group::parse(ctx, diag);
   }
 
 private:
   PECOFFLinkingContext &_ctx;
 };
 
 } // namespace lld
 
 #endif

lib/Driver/GnuLdDriver.cpp

case OPT_defsym: {
         diagnostics << "invalid --defsym: " << inputArg->getValue() << "\n";
         return false;
       }
       ctx->addInitialAbsoluteSymbol(sym, addr);
       break;
     }
 
     case OPT_start_group: {
-      std::unique_ptr<Group> group(new ELFGroup(*ctx, index++));
+      std::unique_ptr<Group> group(new Group(index++));
       groupStack.push(group.get());
       inputGraph->addInputElement(std::move(group));
       break;
     }
 
     case OPT_end_group:
       groupStack.pop();
       break;

lib/Driver/GnuLdInputGraph.cpp

 /// \brief Handle GnuLD script for ELF.
 error_code ELFGNULdScript::parse(const LinkingContext &ctx,
                                  raw_ostream &diagnostics) {
   int64_t index = 0;
   if (error_code ec = GNULdScript::parse(ctx, diagnostics))
     return ec;
   for (const auto &c : _linkerScript->_commands) {
     if (auto group = dyn_cast<script::Group>(c)) {
-      std::unique_ptr<Group> groupStart(
-          new ELFGroup(_elfLinkingContext, index++));
+      std::unique_ptr<Group> groupStart(new Group(index++));
       for (auto &path : group->getPaths()) {
         // TODO : Propagate Set WholeArchive/dashlPrefix
         auto inputNode = new ELFFileNode(
             _elfLinkingContext, _elfLinkingContext.allocateString(path._path),
             index++, false, path._asNeeded, false);
         std::unique_ptr<InputElement> inputFile(inputNode);
         cast<Group>(groupStart.get())->addFile(
             std::move(inputFile));
       }
       _expandElements.push_back(std::move(groupStart));
     }
   }
   return error_code::success();
 }

unittests/DriverTests/InputGraphTest.cpp

public:
 
   ErrorOr<File &> getNextFile() override {
     if (_nextFileIndex == _files.size())
       return make_error_code(InputGraphError::no_more_files);
     return *_files[_nextFileIndex++];
   }
 };
 
-class MyGroupNode : public Group {
-public:
-  MyGroupNode(int64_t ordinal) : Group(ordinal) {}
-
-  error_code parse(const LinkingContext &, raw_ostream &) override {
-    return error_code::success();
-  }
-};
-
 class MyExpandFileNode : public FileNode {
 public:
   MyExpandFileNode(StringRef path, int64_t ordinal)
       : FileNode(path, ordinal) {}
 
   error_code parse(const LinkingContext &, raw_ostream &) override {
     return error_code::success();
   }
TEST_F(InputGraphTest, AddNodeWithFilesAndGroup) {
   objfiles.push_back(std::move(obj1));
   objfiles.push_back(std::move(obj2));
   myfile->addFiles(std::move(objfiles));
   EXPECT_EQ(true, inputGraph().addInputElement(std::move(myfile)));
 
   // Create a group node with two elements
   // an file node which looks like an archive and
   // two file nodes
-  std::unique_ptr<MyGroupNode> mygroup(new MyGroupNode(1));
+  std::unique_ptr<Group> mygroup(new Group(1));
   std::unique_ptr<MyFileNode> myarchive(new MyFileNode("archive_file", 2));
   std::vector<std::unique_ptr<File> > objfiles_group;
   std::unique_ptr<SimpleFile> obj_1(new SimpleFile("objfile_1"));
   std::unique_ptr<SimpleFile> obj_2(new SimpleFile("objfile_2"));
   objfiles_group.push_back(std::move(obj_1));
   objfiles_group.push_back(std::move(obj_2));
   myarchive->addFiles(std::move(objfiles_group));
   EXPECT_EQ(true, mygroup->addFile(std::move(myarchive)));
TEST_F(InputGraphTest, AddNodeWithGroupIteration) {
   objfiles.push_back(std::move(obj1));
   objfiles.push_back(std::move(obj2));
   myfile->addFiles(std::move(objfiles));
   EXPECT_EQ(true, inputGraph().addInputElement(std::move(myfile)));
 
   // Create a group node with two elements
   // an file node which looks like an archive and
   // two file nodes
-  std::unique_ptr<MyGroupNode> mygroup(new MyGroupNode(1));
+  std::unique_ptr<Group> mygroup(new Group(1));
   std::unique_ptr<MyFileNode> myarchive(new MyFileNode("archive_file", 2));
   std::vector<std::unique_ptr<File> > objfiles_group;
   std::unique_ptr<SimpleFile> obj_1(new SimpleFile("objfile_1"));
   std::unique_ptr<SimpleFile> obj_2(new SimpleFile("objfile_2"));
   objfiles_group.push_back(std::move(obj_1));
   objfiles_group.push_back(std::move(obj_2));
   myarchive->addFiles(std::move(objfiles_group));
   EXPECT_EQ(true, mygroup->addFile(std::move(myarchive)));