[ORC] Update ObjectTransformLayer signature

[JosephTremoulet]

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.

[lhames]

LGTM. Thanks Joseph!

llvm/trunk/include/llvm/ExecutionEngine/Orc/ObjectTransformLayer.h

public:
 
   /// @brief Apply the transform functor to each object in the object set, then
   ///        add the resulting set of objects to the base layer, along with the
   ///        memory manager and symbol resolver.
   ///
   /// @return A handle for the added objects.
   template <typename ObjSetT, typename MemoryManagerPtrT,
             typename SymbolResolverPtrT>
-  ObjSetHandleT addObjectSet(ObjSetT &Objects, MemoryManagerPtrT MemMgr,
+  ObjSetHandleT addObjectSet(ObjSetT Objects, MemoryManagerPtrT MemMgr,
                              SymbolResolverPtrT Resolver) {
 
     for (auto I = Objects.begin(), E = Objects.end(); I != E; ++I)
       *I = Transform(std::move(*I));
 
-    return BaseLayer.addObjectSet(Objects, std::move(MemMgr),
+    return BaseLayer.addObjectSet(std::move(Objects), std::move(MemMgr),
                                   std::move(Resolver));
   }
 
   /// @brief Remove the object set associated with the handle H.
   void removeObjectSet(ObjSetHandleT H) { BaseLayer.removeObjectSet(H); }
 
   /// @brief Search for the given named symbol.
   /// @param Name The name of the symbol to search for.

llvm/trunk/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp

 //===- ObjectTransformLayerTest.cpp - Unit tests for ObjectTransformLayer -===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#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;
 
 namespace {
 
 // Stand-in for RuntimeDyld::MemoryManager
 typedef int MockMemoryManager;

 class MockBaseLayer {
 public:
   typedef int ObjSetHandleT;
 
   MockBaseLayer() : MockSymbol(nullptr) { resetExpectations(); }
 
   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";
     size_t I = 0;
     for (auto &ObjPtr : Objects) {
       EXPECT_EQ(MockObjects[I++] + 1, *ObjPtr) << "Transform should be applied";
     }
     EXPECT_EQ(MockObjects.size(), I) << "Number of objects should match";
TEST(ObjectTransformLayerTest, Main) {
 
   // Test addObjectSet with T1 (allocating, unique pointers)
   std::vector<std::unique_ptr<MockObjectFile>> Objs1;
   Objs1.push_back(llvm::make_unique<MockObjectFile>(MockObject1));
   Objs1.push_back(llvm::make_unique<MockObjectFile>(MockObject2));
   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);
   EXPECT_EQ(212, MockObject1) << "Expected mutation";
   EXPECT_EQ(223, MockObject2) << "Expected mutation";
 
   // Test removeObjectSet
   M.expectRemoveObjectSet(H);
TEST(ObjectTransformLayerTest, Main) {
   EXPECT_EQ(&Mutatee, Out) << "Expected in-place transform";
   EXPECT_EQ(278, Mutatee) << "Expected incrementing transform";
 
   // Verify transform getter (const)
   auto OwnedObj = llvm::make_unique<MockObjectFile>(288);
   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);
+  }
 }
 }