diff options
Diffstat (limited to 'unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp')
| -rw-r--r-- | unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp | 177 |
1 files changed, 83 insertions, 94 deletions
diff --git a/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp b/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp index 68db454637c5b..2fdf9e8b7379b 100644 --- a/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp @@ -31,14 +31,14 @@ typedef int MockSymbolResolver; typedef int MockObjectFile; // stand-in for llvm::MemoryBuffer set -typedef int MockMemoryBufferSet; +typedef int MockMemoryBuffer; // Mock transform that operates on unique pointers to object files, and // allocates new object files rather than mutating the given ones. struct AllocatingTransform { - std::unique_ptr<MockObjectFile> - operator()(std::unique_ptr<MockObjectFile> Obj) const { - return llvm::make_unique<MockObjectFile>(*Obj + 1); + std::shared_ptr<MockObjectFile> + operator()(std::shared_ptr<MockObjectFile> Obj) const { + return std::make_shared<MockObjectFile>(*Obj + 1); } }; @@ -50,48 +50,41 @@ struct AllocatingTransform { // transform layer called the base layer and forwarded any return value. class MockBaseLayer { public: - typedef int ObjSetHandleT; + typedef int ObjHandleT; MockBaseLayer() : MockSymbol(nullptr) { resetExpectations(); } - template <typename ObjSetT, typename MemoryManagerPtrT, + template <typename ObjPtrT, typename MemoryManagerPtrT, typename SymbolResolverPtrT> - ObjSetHandleT addObjectSet(ObjSetT Objects, MemoryManagerPtrT MemMgr, - SymbolResolverPtrT Resolver) { + ObjHandleT addObject(ObjPtrT Obj, 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"; - I++; - } - EXPECT_EQ(MockObjects.size(), I) << "Number of objects should match"; - LastCalled = "addObjectSet"; - MockObjSetHandle = 111; - return MockObjSetHandle; + EXPECT_EQ(MockObject + 1, *Obj) << "Transform should be applied"; + LastCalled = "addObject"; + MockObjHandle = 111; + return MockObjHandle; } - template <typename ObjSetT> - void expectAddObjectSet(ObjSetT &Objects, MockMemoryManager *MemMgr, - MockSymbolResolver *Resolver) { + template <typename ObjPtrT> + void expectAddObject(ObjPtrT Obj, MockMemoryManager *MemMgr, + MockSymbolResolver *Resolver) { MockManager = *MemMgr; MockResolver = *Resolver; - for (auto &ObjPtr : Objects) { - MockObjects.push_back(*ObjPtr); - } + MockObject = *Obj; } - void verifyAddObjectSet(ObjSetHandleT Returned) { - EXPECT_EQ("addObjectSet", LastCalled); - EXPECT_EQ(MockObjSetHandle, Returned) << "Return should pass through"; + void verifyAddObject(ObjHandleT Returned) { + EXPECT_EQ("addObject", LastCalled); + EXPECT_EQ(MockObjHandle, Returned) << "Return should pass through"; resetExpectations(); } - void removeObjectSet(ObjSetHandleT H) { - EXPECT_EQ(MockObjSetHandle, H); - LastCalled = "removeObjectSet"; + void removeObject(ObjHandleT H) { + EXPECT_EQ(MockObjHandle, H); + LastCalled = "removeObject"; } - void expectRemoveObjectSet(ObjSetHandleT H) { MockObjSetHandle = H; } - void verifyRemoveObjectSet() { - EXPECT_EQ("removeObjectSet", LastCalled); + void expectRemoveObject(ObjHandleT H) { MockObjHandle = H; } + void verifyRemoveObject() { + EXPECT_EQ("removeObject", LastCalled); resetExpectations(); } @@ -114,18 +107,18 @@ public: resetExpectations(); } - llvm::JITSymbol findSymbolIn(ObjSetHandleT H, const std::string &Name, + llvm::JITSymbol findSymbolIn(ObjHandleT H, const std::string &Name, bool ExportedSymbolsOnly) { - EXPECT_EQ(MockObjSetHandle, H) << "Handle should pass through"; + EXPECT_EQ(MockObjHandle, H) << "Handle should pass through"; EXPECT_EQ(MockName, Name) << "Name should pass through"; EXPECT_EQ(MockBool, ExportedSymbolsOnly) << "Flag should pass through"; LastCalled = "findSymbolIn"; MockSymbol = llvm::JITSymbol(122, llvm::JITSymbolFlags::None); return MockSymbol; } - void expectFindSymbolIn(ObjSetHandleT H, const std::string &Name, + void expectFindSymbolIn(ObjHandleT H, const std::string &Name, bool ExportedSymbolsOnly) { - MockObjSetHandle = H; + MockObjHandle = H; MockName = Name; MockBool = ExportedSymbolsOnly; } @@ -136,26 +129,26 @@ public: resetExpectations(); } - void emitAndFinalize(ObjSetHandleT H) { - EXPECT_EQ(MockObjSetHandle, H) << "Handle should pass through"; + void emitAndFinalize(ObjHandleT H) { + EXPECT_EQ(MockObjHandle, H) << "Handle should pass through"; LastCalled = "emitAndFinalize"; } - void expectEmitAndFinalize(ObjSetHandleT H) { MockObjSetHandle = H; } + void expectEmitAndFinalize(ObjHandleT H) { MockObjHandle = H; } void verifyEmitAndFinalize() { EXPECT_EQ("emitAndFinalize", LastCalled); resetExpectations(); } - void mapSectionAddress(ObjSetHandleT H, const void *LocalAddress, + void mapSectionAddress(ObjHandleT H, const void *LocalAddress, llvm::JITTargetAddress TargetAddr) { - EXPECT_EQ(MockObjSetHandle, H); + EXPECT_EQ(MockObjHandle, H); EXPECT_EQ(MockLocalAddress, LocalAddress); EXPECT_EQ(MockTargetAddress, TargetAddr); LastCalled = "mapSectionAddress"; } - void expectMapSectionAddress(ObjSetHandleT H, const void *LocalAddress, + void expectMapSectionAddress(ObjHandleT H, const void *LocalAddress, llvm::JITTargetAddress TargetAddr) { - MockObjSetHandle = H; + MockObjHandle = H; MockLocalAddress = LocalAddress; MockTargetAddress = TargetAddr; } @@ -169,27 +162,27 @@ private: std::string LastCalled; MockMemoryManager MockManager; MockSymbolResolver MockResolver; - std::vector<MockObjectFile> MockObjects; - ObjSetHandleT MockObjSetHandle; + MockObjectFile MockObject; + ObjHandleT MockObjHandle; std::string MockName; bool MockBool; llvm::JITSymbol MockSymbol; const void *MockLocalAddress; llvm::JITTargetAddress MockTargetAddress; - MockMemoryBufferSet MockBufferSet; + MockMemoryBuffer MockBuffer; // Clear remembered parameters between calls void resetExpectations() { LastCalled = "nothing"; MockManager = 0; MockResolver = 0; - MockObjects.clear(); - MockObjSetHandle = 0; + MockObject = 0; + MockObjHandle = 0; MockName = "bogus"; MockSymbol = llvm::JITSymbol(nullptr); MockLocalAddress = nullptr; MockTargetAddress = 0; - MockBufferSet = 0; + MockBuffer = 0; } }; @@ -204,43 +197,36 @@ TEST(ObjectTransformLayerTest, Main) { // Create a second object transform layer using a transform (as a lambda) // that mutates objects in place, and deals in naked pointers ObjectTransformLayer<MockBaseLayer, - std::function<MockObjectFile *(MockObjectFile *)>> - T2(M, [](MockObjectFile *Obj) { + std::function<std::shared_ptr<MockObjectFile>( + std::shared_ptr<MockObjectFile>)>> + T2(M, [](std::shared_ptr<MockObjectFile> Obj) { ++(*Obj); return Obj; }); // Instantiate some mock objects to use below - MockObjectFile MockObject1 = 211; - MockObjectFile MockObject2 = 222; MockMemoryManager MockManager = 233; MockSymbolResolver MockResolver = 244; - // 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)); + // Test addObject with T1 (allocating) + auto Obj1 = std::make_shared<MockObjectFile>(211); 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(std::move(Objs1), std::move(MM), std::move(SR)); - M.verifyAddObjectSet(H); - - // Test addObjectSet with T2 (mutating, naked pointers) - 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"; + M.expectAddObject(Obj1, MM.get(), SR.get()); + auto H = T1.addObject(std::move(Obj1), std::move(MM), std::move(SR)); + M.verifyAddObject(H); + + // Test addObjectSet with T2 (mutating) + auto Obj2 = std::make_shared<MockObjectFile>(222); + M.expectAddObject(Obj2, &MockManager, &MockResolver); + H = T2.addObject(Obj2, &MockManager, &MockResolver); + M.verifyAddObject(H); + EXPECT_EQ(223, *Obj2) << "Expected mutation"; // Test removeObjectSet - M.expectRemoveObjectSet(H); - T1.removeObjectSet(H); - M.verifyRemoveObjectSet(); + M.expectRemoveObject(H); + T1.removeObject(H); + M.verifyRemoveObject(); // Test findSymbol std::string Name = "foo"; @@ -269,13 +255,13 @@ TEST(ObjectTransformLayerTest, Main) { M.verifyMapSectionAddress(); // Verify transform getter (non-const) - MockObjectFile Mutatee = 277; - MockObjectFile *Out = T2.getTransform()(&Mutatee); - EXPECT_EQ(&Mutatee, Out) << "Expected in-place transform"; - EXPECT_EQ(278, Mutatee) << "Expected incrementing transform"; + auto Mutatee = std::make_shared<MockObjectFile>(277); + auto Out = T2.getTransform()(Mutatee); + 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); + auto OwnedObj = std::make_shared<MockObjectFile>(288); const auto &T1C = T1; OwnedObj = T1C.getTransform()(std::move(OwnedObj)); EXPECT_EQ(289, *OwnedObj) << "Expected incrementing transform"; @@ -287,8 +273,8 @@ TEST(ObjectTransformLayerTest, Main) { // 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 + // IRComileLayer's addModule that should call the transform layer's + // addObject, and also calling the other public transform layer methods // directly to make sure the methods they intend to forward to exist on // the ObjectLinkingLayer. @@ -309,31 +295,34 @@ TEST(ObjectTransformLayerTest, Main) { }; // Construct the jit layers. - RTDyldObjectLinkingLayer<> BaseLayer; - auto IdentityTransform = []( - std::unique_ptr<llvm::object::OwningBinary<llvm::object::ObjectFile>> - Obj) { return Obj; }; + RTDyldObjectLinkingLayer BaseLayer; + auto IdentityTransform = + [](std::shared_ptr<llvm::object::OwningBinary<llvm::object::ObjectFile>> + Obj) { + return Obj; + }; ObjectTransformLayer<decltype(BaseLayer), decltype(IdentityTransform)> TransformLayer(BaseLayer, IdentityTransform); auto NullCompiler = [](llvm::Module &) { - return llvm::object::OwningBinary<llvm::object::ObjectFile>(); + return llvm::object::OwningBinary<llvm::object::ObjectFile>(nullptr, + nullptr); }; - IRCompileLayer<decltype(TransformLayer)> CompileLayer(TransformLayer, - NullCompiler); + IRCompileLayer<decltype(TransformLayer), decltype(NullCompiler)> + CompileLayer(TransformLayer, NullCompiler); // Make sure that the calls from IRCompileLayer to ObjectTransformLayer // compile. NullResolver Resolver; NullManager Manager; - CompileLayer.addModuleSet(std::vector<llvm::Module *>(), &Manager, &Resolver); + CompileLayer.addModule(std::shared_ptr<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); + decltype(TransformLayer)::ObjHandleT H2; + TransformLayer.emitAndFinalize(H2); + TransformLayer.findSymbolIn(H2, Name, false); TransformLayer.findSymbol(Name, true); - TransformLayer.mapSectionAddress(ObjSet, nullptr, 0); - TransformLayer.removeObjectSet(ObjSet); + TransformLayer.mapSectionAddress(H2, nullptr, 0); + TransformLayer.removeObject(H2); } } |