Import LLVM 5.0.0 release including clang, lld and lldb.

1 files changed, 117 insertions, 129 deletions

diff --git a/gnu/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp b/gnu/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
index 63b85dc82ca..25103f79ac6 100644
--- a/gnu/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
+++ b/gnu/llvm/unittests/ExecutionEngine/Orc/ObjectTransformLayerTest.cpp
@@ -7,13 +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/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/Object/ObjectFile.h"
 #include "gtest/gtest.h"
 
@@ -21,24 +22,18 @@ using namespace llvm::orc;
 
 namespace {
 
-// Stand-in for RuntimeDyld::MemoryManager
-typedef int MockMemoryManager;
-
-// Stand-in for RuntimeDyld::SymbolResolver
-typedef int MockSymbolResolver;
-
 // stand-in for object::ObjectFile
 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 +45,44 @@ 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,
-            typename SymbolResolverPtrT>
-  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";
-      I++;
-    }
-    EXPECT_EQ(MockObjects.size(), I) << "Number of objects should match";
-    LastCalled = "addObjectSet";
-    MockObjSetHandle = 111;
-    return MockObjSetHandle;
+  template <typename ObjPtrT>
+  llvm::Expected<ObjHandleT>
+  addObject(ObjPtrT Obj,
+            std::shared_ptr<llvm::JITSymbolResolver> Resolver) {
+    EXPECT_EQ(MockResolver, Resolver) << "Resolver should pass through";
+    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) {
-    MockManager = *MemMgr;
-    MockResolver = *Resolver;
-    for (auto &ObjPtr : Objects) {
-      MockObjects.push_back(*ObjPtr);
-    }
+
+  template <typename ObjPtrT>
+  void expectAddObject(ObjPtrT Obj,
+                       std::shared_ptr<llvm::JITSymbolResolver> Resolver) {
+    MockResolver = Resolver;
+    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";
+  llvm::Error removeObject(ObjHandleT H) {
+    EXPECT_EQ(MockObjHandle, H);
+    LastCalled = "removeObject";
+    return llvm::Error::success();
   }
-  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();
   }
 
@@ -101,7 +92,7 @@ public:
     EXPECT_EQ(MockBool, ExportedSymbolsOnly) << "Flag should pass through";
     LastCalled = "findSymbol";
     MockSymbol = llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
-    return MockSymbol;
+    return llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
   }
   void expectFindSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
     MockName = Name;
@@ -109,53 +100,58 @@ public:
   }
   void verifyFindSymbol(llvm::JITSymbol Returned) {
     EXPECT_EQ("findSymbol", LastCalled);
-    EXPECT_EQ(MockSymbol.getAddress(), Returned.getAddress())
+    EXPECT_EQ(cantFail(MockSymbol.getAddress()),
+              cantFail(Returned.getAddress()))
         << "Return should pass through";
     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;
+    return llvm::JITSymbol(122, llvm::JITSymbolFlags::None);
   }
-  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;
   }
   void verifyFindSymbolIn(llvm::JITSymbol Returned) {
     EXPECT_EQ("findSymbolIn", LastCalled);
-    EXPECT_EQ(MockSymbol.getAddress(), Returned.getAddress())
+    EXPECT_EQ(cantFail(MockSymbol.getAddress()),
+              cantFail(Returned.getAddress()))
         << "Return should pass through";
     resetExpectations();
   }
 
-  void emitAndFinalize(ObjSetHandleT H) {
-    EXPECT_EQ(MockObjSetHandle, H) << "Handle should pass through";
+  llvm::Error emitAndFinalize(ObjHandleT H) {
+    EXPECT_EQ(MockObjHandle, H) << "Handle should pass through";
     LastCalled = "emitAndFinalize";
+    return llvm::Error::success();
   }
-  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;
   }
@@ -167,29 +163,27 @@ public:
 private:
   // Backing fields for remembering parameter/return values
   std::string LastCalled;
-  MockMemoryManager MockManager;
-  MockSymbolResolver MockResolver;
-  std::vector<MockObjectFile> MockObjects;
-  ObjSetHandleT MockObjSetHandle;
+  std::shared_ptr<llvm::JITSymbolResolver> MockResolver;
+  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;
+    MockResolver = nullptr;
+    MockObject = 0;
+    MockObjHandle = 0;
     MockName = "bogus";
     MockSymbol = llvm::JITSymbol(nullptr);
     MockLocalAddress = nullptr;
     MockTargetAddress = 0;
-    MockBufferSet = 0;
+    MockBuffer = 0;
   }
 };
 
@@ -204,61 +198,49 @@ 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));
-  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";
+  // Test addObject with T1 (allocating)
+  auto Obj1 = std::make_shared<MockObjectFile>(211);
+  auto SR = std::make_shared<NullResolver>();
+  M.expectAddObject(Obj1, SR);
+  auto H = cantFail(T1.addObject(std::move(Obj1), SR));
+  M.verifyAddObject(H);
+
+  // Test addObjectSet with T2 (mutating)
+  auto Obj2 = std::make_shared<MockObjectFile>(222);
+  M.expectAddObject(Obj2, SR);
+  H = cantFail(T2.addObject(Obj2, SR));
+  M.verifyAddObject(H);
+  EXPECT_EQ(223, *Obj2) << "Expected mutation";
 
   // Test removeObjectSet
-  M.expectRemoveObjectSet(H);
-  T1.removeObjectSet(H);
-  M.verifyRemoveObjectSet();
+  M.expectRemoveObject(H);
+  cantFail(T1.removeObject(H));
+  M.verifyRemoveObject();
 
   // Test findSymbol
   std::string Name = "foo";
   bool ExportedOnly = true;
   M.expectFindSymbol(Name, ExportedOnly);
-  llvm::JITSymbol Symbol = T2.findSymbol(Name, ExportedOnly);
-  M.verifyFindSymbol(Symbol);
+  llvm::JITSymbol Sym1 = T2.findSymbol(Name, ExportedOnly);
+  M.verifyFindSymbol(std::move(Sym1));
 
   // Test findSymbolIn
   Name = "bar";
   ExportedOnly = false;
   M.expectFindSymbolIn(H, Name, ExportedOnly);
-  Symbol = T1.findSymbolIn(H, Name, ExportedOnly);
-  M.verifyFindSymbolIn(Symbol);
+  llvm::JITSymbol Sym2 = T1.findSymbolIn(H, Name, ExportedOnly);
+  M.verifyFindSymbolIn(std::move(Sym2));
 
   // Test emitAndFinalize
   M.expectEmitAndFinalize(H);
-  T2.emitAndFinalize(H);
+  cantFail(T2.emitAndFinalize(H));
   M.verifyEmitAndFinalize();
 
   // Test mapSectionAddress
@@ -269,13 +251,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 +269,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.
 
@@ -304,36 +286,42 @@ TEST(ObjectTransformLayerTest, Main) {
       return nullptr;
     }
     void registerEHFrames(uint8_t *, uint64_t, size_t) override {}
-    void deregisterEHFrames(uint8_t *, uint64_t, size_t) override {}
+    void deregisterEHFrames() override {}
     bool finalizeMemory(std::string *) override { return false; }
   };
 
   // Construct the jit layers.
-  ObjectLinkingLayer<> BaseLayer;
-  auto IdentityTransform = [](
-      std::unique_ptr<llvm::object::OwningBinary<llvm::object::ObjectFile>>
-          Obj) { return Obj; };
+  RTDyldObjectLinkingLayer BaseLayer(
+    []() {
+      return std::make_shared<llvm::SectionMemoryManager>();
+    });
+
+  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);
+  auto Resolver = std::make_shared<NullResolver>();
+  cantFail(CompileLayer.addModule(std::shared_ptr<llvm::Module>(), 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;
+  cantFail(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);
+  cantFail(TransformLayer.removeObject(H2));
 }
 }