[ORC] Move LinkGraphMaterializationUnit for testing (NFC)

[keith]

Summary

Based on the discussion in https://reviews.llvm.org/D130221

[keith]

this isn't exactly what was discussed in https://reviews.llvm.org/D130221 but it seems like making LinkGraphMaterializationUnit accessible is nicer for unit tests where we only care to test its behavior vs the whole system. lmk what you think. Locally I also have a patch to use MachOPlatform::isInitializerSection instead of the local version here but I wanted to prove the tests pass before and after so I didn't include it yet.

[dblaikie]

Yeah, this is the sort of testing /I/ think would be nice to have, but hope @lhames can take a look/give his perspective.

[lhames]

I haven't had a chance for a proper read yet -- will do that when I get back from vacation next week.

My first thought is that, following the reasoning in https://reviews.llvm.org/D130221, we should aim to merge MachOPlatform::isInitializerSection and hasMachOInitSection into a new function in ObjectFileInterface.h and use that.

If we do that we may find that this is testable in LinkGraphTests.cpp rather than ObjectLinkingLayer.

[dblaikie]

In D139223#3968060, @lhames wrote:

I haven't had a chance for a proper read yet -- will do that when I get back from vacation next week.

My first thought is that, following the reasoning in https://reviews.llvm.org/D130221, we should aim to merge MachOPlatform::isInitializerSection and hasMachOInitSection into a new function in ObjectFileInterface.h and use that.

If we do that we may find that this is testable in LinkGraphTests.cpp rather than ObjectLinkingLayer.

Ah, awesome - yeah, that does look like a good thing to deduplicate.

[keith]

dropping this one and went for the discussed approach in https://reviews.llvm.org/D139347 which has no overlap with this one

llvm/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

 private:
   std::mutex EHFramePluginMutex;
   ExecutionSession &ES;
   std::unique_ptr<jitlink::EHFrameRegistrar> Registrar;
   DenseMap<MaterializationResponsibility *, ExecutorAddrRange> InProcessLinks;
   DenseMap<ResourceKey, std::vector<ExecutorAddrRange>> EHFrameRanges;
 };
 
+class LinkGraphMaterializationUnit : public MaterializationUnit {
+public:
+  static std::unique_ptr<LinkGraphMaterializationUnit>
+  Create(ObjectLinkingLayer &ObjLinkingLayer,
+         std::unique_ptr<jitlink::LinkGraph> G);
+
+  StringRef getName() const override { return G->getName(); }
+  void materialize(std::unique_ptr<MaterializationResponsibility> MR) override {
+    ObjLinkingLayer.emit(std::move(MR), std::move(G));
+  }
+
+private:
+  LinkGraphMaterializationUnit(ObjectLinkingLayer &ObjLinkingLayer,
+                               std::unique_ptr<jitlink::LinkGraph> G,
+                               Interface LGI);
+
+  static Interface scanLinkGraph(ExecutionSession &ES, jitlink::LinkGraph &G);
+  static bool hasMachOInitSection(jitlink::LinkGraph &G);
+  static bool hasELFInitSection(jitlink::LinkGraph &G);
+
+  static SymbolStringPtr makeInitSymbol(ExecutionSession &ES,
+                                        jitlink::LinkGraph &G);
+  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
+
+  ObjectLinkingLayer &ObjLinkingLayer;
+  std::unique_ptr<jitlink::LinkGraph> G;
+  static std::atomic<uint64_t> Counter;
+};
+
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_OBJECTLINKINGLAYER_H

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

 #include <vector>
 
 #define DEBUG_TYPE "orc"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::orc;
 
-namespace {
+namespace llvm {
+namespace orc {
 
-class LinkGraphMaterializationUnit : public MaterializationUnit {
-public:
-  static std::unique_ptr<LinkGraphMaterializationUnit>
-  Create(ObjectLinkingLayer &ObjLinkingLayer, std::unique_ptr<LinkGraph> G) {
-    auto LGI = scanLinkGraph(ObjLinkingLayer.getExecutionSession(), *G);
-    return std::unique_ptr<LinkGraphMaterializationUnit>(
-        new LinkGraphMaterializationUnit(ObjLinkingLayer, std::move(G),
-                                         std::move(LGI)));
-  }
+std::unique_ptr<LinkGraphMaterializationUnit>
+LinkGraphMaterializationUnit::Create(ObjectLinkingLayer &ObjLinkingLayer,
+                                     std::unique_ptr<jitlink::LinkGraph> G) {
 
-  StringRef getName() const override { return G->getName(); }
-  void materialize(std::unique_ptr<MaterializationResponsibility> MR) override {
-    ObjLinkingLayer.emit(std::move(MR), std::move(G));
-  }
-
-private:
-  static Interface scanLinkGraph(ExecutionSession &ES, LinkGraph &G) {
+AbsoluteSymbolsMaterializationUnit::Interface
+LinkGraphMaterializationUnit::scanLinkGraph(ExecutionSession &ES,
+                                            LinkGraph &G) {
 
-    Interface LGI;
 
-    for (auto *Sym : G.defined_symbols()) {
-      // Skip local symbols.
-      if (Sym->getScope() == Scope::Local)
-        continue;
-      assert(Sym->hasName() && "Anonymous non-local symbol?");
 
-      JITSymbolFlags Flags;
-      if (Sym->getScope() == Scope::Default)
-        Flags |= JITSymbolFlags::Exported;
 
-      if (Sym->isCallable())
-        Flags |= JITSymbolFlags::Callable;
 
-      LGI.SymbolFlags[ES.intern(Sym->getName())] = Flags;
-    }
 
-    if ((G.getTargetTriple().isOSBinFormatMachO() && hasMachOInitSection(G)) ||
-        (G.getTargetTriple().isOSBinFormatELF() && hasELFInitSection(G)))
-      LGI.InitSymbol = makeInitSymbol(ES, G);
 
-    return LGI;
-  }
 
-  static bool hasMachOInitSection(LinkGraph &G) {
-    for (auto &Sec : G.sections())
-      if (Sec.getName() == "__DATA,__objc_selrefs" ||
-          Sec.getName() == "__DATA,__objc_classlist" ||
-          Sec.getName() == "__TEXT,__swift5_protos" ||
-          Sec.getName() == "__TEXT,__swift5_proto" ||
-          Sec.getName() == "__TEXT,__swift5_types" ||
-          Sec.getName() == "__DATA,__mod_init_func")
-        return true;
-    return false;
-  }
+bool LinkGraphMaterializationUnit::hasMachOInitSection(LinkGraph &G) {
 
-  static bool hasELFInitSection(LinkGraph &G) {
-    for (auto &Sec : G.sections()) {
-      auto SecName = Sec.getName();
-      if (SecName.consume_front(".init_array") &&
-          (SecName.empty() || SecName[0] == '.'))
-        return true;
-    }
-    return false;
-  }
+bool LinkGraphMaterializationUnit::hasELFInitSection(LinkGraph &G) {
 
-  static SymbolStringPtr makeInitSymbol(ExecutionSession &ES, LinkGraph &G) {
-    std::string InitSymString;
-    raw_string_ostream(InitSymString)
-        << "$." << G.getName() << ".__inits" << Counter++;
-    return ES.intern(InitSymString);
-  }
+SymbolStringPtr
+LinkGraphMaterializationUnit::makeInitSymbol(ExecutionSession &ES,
+                                             LinkGraph &G) {
 
-  LinkGraphMaterializationUnit(ObjectLinkingLayer &ObjLinkingLayer,
-                               std::unique_ptr<LinkGraph> G, Interface LGI)
-      : MaterializationUnit(std::move(LGI)), ObjLinkingLayer(ObjLinkingLayer),
-        G(std::move(G)) {}
+LinkGraphMaterializationUnit::LinkGraphMaterializationUnit(
+    ObjectLinkingLayer &ObjLinkingLayer, std::unique_ptr<LinkGraph> G,
+    Interface LGI)
 
-  void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
-    for (auto *Sym : G->defined_symbols())
-      if (Sym->getName() == *Name) {
-        assert(Sym->getLinkage() == Linkage::Weak &&
-               "Discarding non-weak definition");
-        G->makeExternal(*Sym);
-        break;
-      }
-  }
+void LinkGraphMaterializationUnit::discard(const JITDylib &JD,
+                                           const SymbolStringPtr &Name) {
 
-  ObjectLinkingLayer &ObjLinkingLayer;
-  std::unique_ptr<LinkGraph> G;
-  static std::atomic<uint64_t> Counter;
-};
-
 std::atomic<uint64_t> LinkGraphMaterializationUnit::Counter{0};
 
-} // end anonymous namespace
-
-namespace llvm {
-namespace orc {
-
 class ObjectLinkingLayerJITLinkContext final : public JITLinkContext {
 public:
   ObjectLinkingLayerJITLinkContext(
       ObjectLinkingLayer &Layer,
       std::unique_ptr<MaterializationResponsibility> MR,
       std::unique_ptr<MemoryBuffer> ObjBuffer)
       : JITLinkContext(&MR->getTargetJITDylib()), Layer(Layer),
         MR(std::move(MR)), ObjBuffer(std::move(ObjBuffer)) {}

llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp

 //===-------- ObjectLinkingLayerTest.cpp - ObjectLinkingLayer tests -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "OrcTestCommon.h"
+
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/JITLink/x86_64.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::orc;
 
 namespace {
TEST_F(ObjectLinkingLayerTest, AddLinkGraph) {
   G->addDefinedSymbol(B1, 4, "_X", 4, Linkage::Strong, Scope::Default, false,
                       false);
 
   EXPECT_THAT_ERROR(ObjLinkingLayer.add(JD, std::move(G)), Succeeded());
 
   EXPECT_THAT_EXPECTED(ES.lookup(&JD, "_X"), Succeeded());
 }
 
+TEST_F(ObjectLinkingLayerTest, MachOInitSymbol) {
+  {
+    auto Graph =
+        std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
+                                    support::little, x86_64::getEdgeKindName);
+    Graph->createSection("__DATA,__objc_selrefs",
+                         orc::MemProt::Read | orc::MemProt::Write);
+    auto Unit =
+        LinkGraphMaterializationUnit::Create(ObjLinkingLayer, std::move(Graph));
+    SymbolStringPtr Expected = ES.intern("$.foo.__inits0");
+    EXPECT_EQ(Unit->getInitializerSymbol(), Expected);
+  }
+
+  {
+    auto Graph =
+        std::make_unique<LinkGraph>("foo", Triple("x86_64-apple-darwin"), 8,
+                                    support::little, x86_64::getEdgeKindName);
+    Graph->createSection("__DATA,__not_an_init_sec",
+                         orc::MemProt::Read | orc::MemProt::Write);
+    auto Unit =
+        LinkGraphMaterializationUnit::Create(ObjLinkingLayer, std::move(Graph));
+    EXPECT_EQ(Unit->getInitializerSymbol(), nullptr);
+  }
+}
+
 } // end anonymous namespace