From 23d02f614970c698654af2bc06a1798260c0f62b Mon Sep 17 00:00:00 2001
From: Joseph Tremoulet <jotrem@microsoft.com>
Date: Sat, 23 Jan 2016 18:36:01 +0000
Subject: [ORC] Update ObjectTransformLayer signature

Summary:
Update ObjectTransformLayer::addObjectSet to take the object set by
value rather than reference and pass it to the base layer with move
semantics rather than copy, to match r258185's changes to
ObjectLinkingLayer.

Update the unit test to verify that ObjectTransformLayer's signature stays
in sync with ObjectLinkingLayer's.


Reviewers: lhames

Subscribers: llvm-commits

Differential Revision: http://reviews.llvm.org/D16414

llvm-svn: 258630
---
 .../Orc/ObjectTransformLayerTest.cpp               | 75 ++++++++++++++++++++--
 1 file changed, 69 insertions(+), 6 deletions(-)

(limited to 'llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp')

diff --git a/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp b/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
index c88c94f17b1..fda596f6a70 100644
--- a/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
+++ b/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
@@ -7,9 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/NullResolver.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h"
+#include "llvm/Object/ObjectFile.h"
 #include "gtest/gtest.h"
 
 using namespace llvm::orc;
@@ -51,7 +56,7 @@ public:
 
   template <typename ObjSetT, typename MemoryManagerPtrT,
             typename SymbolResolverPtrT>
-  ObjSetHandleT addObjectSet(ObjSetT &Objects, MemoryManagerPtrT MemMgr,
+  ObjSetHandleT addObjectSet(ObjSetT Objects, MemoryManagerPtrT MemMgr,
                              SymbolResolverPtrT Resolver) {
     EXPECT_EQ(MockManager, *MemMgr) << "MM should pass through";
     EXPECT_EQ(MockResolver, *Resolver) << "Resolver should pass through";
@@ -216,13 +221,14 @@ TEST(ObjectTransformLayerTest, Main) {
   auto MM = llvm::make_unique<MockMemoryManager>(MockManager);
   auto SR = llvm::make_unique<MockSymbolResolver>(MockResolver);
   M.expectAddObjectSet(Objs1, MM.get(), SR.get());
-  auto H = T1.addObjectSet(Objs1, std::move(MM), std::move(SR));
+  auto H = T1.addObjectSet(std::move(Objs1), std::move(MM), std::move(SR));
   M.verifyAddObjectSet(H);
 
   // Test addObjectSet with T2 (mutating, naked pointers)
-  llvm::SmallVector<MockObjectFile *, 2> Objs2;
-  Objs2.push_back(&MockObject1);
-  Objs2.push_back(&MockObject2);
+  llvm::SmallVector<MockObjectFile *, 2> Objs2Vec;
+  Objs2Vec.push_back(&MockObject1);
+  Objs2Vec.push_back(&MockObject2);
+  llvm::MutableArrayRef<MockObjectFile *> Objs2(Objs2Vec);
   M.expectAddObjectSet(Objs2, &MockManager, &MockResolver);
   H = T2.addObjectSet(Objs2, &MockManager, &MockResolver);
   M.verifyAddObjectSet(H);
@@ -271,5 +277,62 @@ TEST(ObjectTransformLayerTest, Main) {
   const auto &T1C = T1;
   OwnedObj = T1C.getTransform()(std::move(OwnedObj));
   EXPECT_EQ(289, *OwnedObj) << "Expected incrementing transform";
+
+  volatile bool RunStaticChecks = false;
+  if (RunStaticChecks) {
+    // Make sure that ObjectTransformLayer implements the object layer concept
+    // correctly by sandwitching one between an ObjectLinkingLayer and an
+    // IRCompileLayer, verifying that it compiles if we have a call to the
+    // IRComileLayer's addModuleSet that should call the transform layer's
+    // addObjectSet, and also calling the other public transform layer methods
+    // directly to make sure the methods they intend to forward to exist on
+    // the ObjectLinkingLayer.
+
+    // We'll need a concrete MemoryManager class.
+    class NullManager : public llvm::RuntimeDyld::MemoryManager {
+    public:
+      uint8_t *allocateCodeSection(uintptr_t, unsigned, unsigned,
+                                   llvm::StringRef) override {
+        return nullptr;
+      }
+      uint8_t *allocateDataSection(uintptr_t, unsigned, unsigned,
+                                   llvm::StringRef, bool) override {
+        return nullptr;
+      }
+      void registerEHFrames(uint8_t *, uint64_t, size_t) override {}
+      void deregisterEHFrames(uint8_t *, uint64_t, size_t) override {}
+      bool finalizeMemory(std::string *) { return false; }
+    };
+
+    // Construct the jit layers.
+    ObjectLinkingLayer<> BaseLayer;
+    auto IdentityTransform = [](
+        std::unique_ptr<llvm::object::OwningBinary<llvm::object::ObjectFile>>
+            Obj) { return std::move(Obj); };
+    ObjectTransformLayer<decltype(BaseLayer), decltype(IdentityTransform)>
+        TransformLayer(BaseLayer, IdentityTransform);
+    auto NullCompiler = [](llvm::Module &) {
+      return llvm::object::OwningBinary<llvm::object::ObjectFile>();
+    };
+    IRCompileLayer<decltype(TransformLayer)> CompileLayer(TransformLayer,
+                                                          NullCompiler);
+    std::vector<llvm::Module *> Modules;
+
+    // Make sure that the calls from IRCompileLayer to ObjectTransformLayer
+    // compile.
+    NullResolver Resolver;
+    NullManager Manager;
+    CompileLayer.addModuleSet(std::vector<llvm::Module *>(), &Manager,
+                              &Resolver);
+
+    // Make sure that the calls from ObjectTransformLayer to ObjectLinkingLayer
+    // compile.
+    decltype(TransformLayer)::ObjSetHandleT ObjSet;
+    TransformLayer.emitAndFinalize(ObjSet);
+    TransformLayer.findSymbolIn(ObjSet, Name, false);
+    TransformLayer.findSymbol(Name, true);
+    TransformLayer.mapSectionAddress(ObjSet, nullptr, 0);
+    TransformLayer.removeObjectSet(ObjSet);
+  }
 }
 }
-- 
cgit v1.2.3