vendor/llvm/llvm-trunk-r321017

6 files changed, 127 insertions, 46 deletions

diff --git a/lib/ExecutionEngine/Orc/IndirectionUtils.cpp b/lib/ExecutionEngine/Orc/IndirectionUtils.cpp
index e3a456849f90..68397beae63a 100644
--- a/lib/ExecutionEngine/Orc/IndirectionUtils.cpp
+++ b/lib/ExecutionEngine/Orc/IndirectionUtils.cpp
@@ -28,6 +28,11 @@ createLocalCompileCallbackManager(const Triple &T,
   switch (T.getArch()) {
     default: return nullptr;
 
+    case Triple::aarch64: {
+      typedef orc::LocalJITCompileCallbackManager<orc::OrcAArch64> CCMgrT;
+      return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
+    }
+
     case Triple::x86: {
       typedef orc::LocalJITCompileCallbackManager<orc::OrcI386> CCMgrT;
       return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
@@ -42,6 +47,7 @@ createLocalCompileCallbackManager(const Triple &T,
         return llvm::make_unique<CCMgrT>(ErrorHandlerAddress);
       }
     }
+
   }
 }
 
@@ -50,6 +56,12 @@ createLocalIndirectStubsManagerBuilder(const Triple &T) {
   switch (T.getArch()) {
     default: return nullptr;
 
+    case Triple::aarch64:
+      return [](){
+        return llvm::make_unique<
+                       orc::LocalIndirectStubsManager<orc::OrcAArch64>>();
+      };
+
     case Triple::x86:
       return [](){
         return llvm::make_unique<
@@ -68,6 +80,7 @@ createLocalIndirectStubsManagerBuilder(const Triple &T) {
                      orc::LocalIndirectStubsManager<orc::OrcX86_64_SysV>>();
         };
       }
+
   }
 }
 
diff --git a/lib/ExecutionEngine/Orc/OrcABISupport.cpp b/lib/ExecutionEngine/Orc/OrcABISupport.cpp
index 9869b6c7050c..e3c968157976 100644
--- a/lib/ExecutionEngine/Orc/OrcABISupport.cpp
+++ b/lib/ExecutionEngine/Orc/OrcABISupport.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Support/Process.h"
 
 namespace llvm {
@@ -117,7 +116,7 @@ void OrcAArch64::writeTrampolines(uint8_t *TrampolineMem, void *ResolverAddr,
 
   for (unsigned I = 0; I < NumTrampolines; ++I, OffsetToPtr -= TrampolineSize) {
     Trampolines[3 * I + 0] = 0xaa1e03f1;                      // mov x17, x30
-    Trampolines[3 * I + 1] = 0x58000010 | (OffsetToPtr << 3); // mov x16, Lptr
+    Trampolines[3 * I + 1] = 0x58000010 | (OffsetToPtr << 3); // adr x16, Lptr
     Trampolines[3 * I + 2] = 0xd63f0200;                      // blr x16
   }
 
diff --git a/lib/ExecutionEngine/Orc/OrcCBindings.cpp b/lib/ExecutionEngine/Orc/OrcCBindings.cpp
index de80cb1d0dd4..f945acaf95ee 100644
--- a/lib/ExecutionEngine/Orc/OrcCBindings.cpp
+++ b/lib/ExecutionEngine/Orc/OrcCBindings.cpp
@@ -20,16 +20,6 @@ void LLVMOrcDisposeSharedModuleRef(LLVMSharedModuleRef SharedMod) {
   delete unwrap(SharedMod);
 }
 
-LLVMSharedObjectBufferRef
-LLVMOrcMakeSharedObjectBuffer(LLVMMemoryBufferRef ObjBuffer) {
-  return wrap(new std::shared_ptr<MemoryBuffer>(unwrap(ObjBuffer)));
-}
-
-void
-LLVMOrcDisposeSharedObjectBufferRef(LLVMSharedObjectBufferRef SharedObjBuffer) {
-  delete unwrap(SharedObjBuffer);
-}
-
 LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
   TargetMachine *TM2(unwrap(TM));
 
@@ -105,6 +95,18 @@ LLVMOrcAddLazilyCompiledIR(LLVMOrcJITStackRef JITStack,
   return J.addIRModuleLazy(*RetHandle, *M, SymbolResolver, SymbolResolverCtx);
 }
 
+LLVMOrcErrorCode
+LLVMOrcAddObjectFile(LLVMOrcJITStackRef JITStack,
+                     LLVMOrcModuleHandle *RetHandle,
+                     LLVMMemoryBufferRef Obj,
+                     LLVMOrcSymbolResolverFn SymbolResolver,
+                     void *SymbolResolverCtx) {
+  OrcCBindingsStack &J = *unwrap(JITStack);
+  std::unique_ptr<MemoryBuffer> O(unwrap(Obj));
+  return J.addObject(*RetHandle, std::move(O), SymbolResolver,
+                     SymbolResolverCtx);
+}
+
 LLVMOrcErrorCode LLVMOrcRemoveModule(LLVMOrcJITStackRef JITStack,
                                      LLVMOrcModuleHandle H) {
   OrcCBindingsStack &J = *unwrap(JITStack);
diff --git a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
index e38decf94f3e..405970e063d8 100644
--- a/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
+++ b/lib/ExecutionEngine/Orc/OrcCBindingsStack.h
@@ -44,26 +44,12 @@ class OrcCBindingsStack;
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(std::shared_ptr<Module>,
                                    LLVMSharedModuleRef)
-DEFINE_SIMPLE_CONVERSION_FUNCTIONS(std::shared_ptr<MemoryBuffer>,
-                                   LLVMSharedObjectBufferRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(OrcCBindingsStack, LLVMOrcJITStackRef)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
 
-class OrcCBindingsStack {
-public:
-
-  using CompileCallbackMgr = orc::JITCompileCallbackManager;
-  using ObjLayerT = orc::RTDyldObjectLinkingLayer;
-  using CompileLayerT = orc::IRCompileLayer<ObjLayerT, orc::SimpleCompiler>;
-  using CODLayerT =
-        orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>;
+namespace detail {
 
-  using CallbackManagerBuilder =
-      std::function<std::unique_ptr<CompileCallbackMgr>()>;
 
-  using IndirectStubsManagerBuilder = CODLayerT::IndirectStubsManagerBuilderT;
-
-private:
   class GenericHandle {
   public:
     virtual ~GenericHandle() = default;
@@ -90,13 +76,56 @@ private:
     typename LayerT::ModuleHandleT Handle;
   };
 
-  template <typename LayerT>
+  template <>
+  class GenericHandleImpl<orc::RTDyldObjectLinkingLayer>
+    : public GenericHandle {
+  private:
+    using LayerT = orc::RTDyldObjectLinkingLayer;
+  public:
+
+    GenericHandleImpl(LayerT &Layer, typename LayerT::ObjHandleT Handle)
+        : Layer(Layer), Handle(std::move(Handle)) {}
+
+    JITSymbol findSymbolIn(const std::string &Name,
+                           bool ExportedSymbolsOnly) override {
+      return Layer.findSymbolIn(Handle, Name, ExportedSymbolsOnly);
+    }
+
+    Error removeModule() override { return Layer.removeObject(Handle); }
+
+  private:
+    LayerT &Layer;
+    typename LayerT::ObjHandleT Handle;
+  };
+
+
+  template <typename LayerT, typename HandleT>
   std::unique_ptr<GenericHandleImpl<LayerT>>
-  createGenericHandle(LayerT &Layer, typename LayerT::ModuleHandleT Handle) {
+  createGenericHandle(LayerT &Layer, HandleT Handle) {
     return llvm::make_unique<GenericHandleImpl<LayerT>>(Layer,
                                                         std::move(Handle));
   }
 
+} // end namespace detail
+
+class OrcCBindingsStack {
+public:
+
+  using CompileCallbackMgr = orc::JITCompileCallbackManager;
+  using ObjLayerT = orc::RTDyldObjectLinkingLayer;
+  using CompileLayerT = orc::IRCompileLayer<ObjLayerT, orc::SimpleCompiler>;
+  using CODLayerT =
+        orc::CompileOnDemandLayer<CompileLayerT, CompileCallbackMgr>;
+
+  using CallbackManagerBuilder =
+      std::function<std::unique_ptr<CompileCallbackMgr>()>;
+
+  using IndirectStubsManagerBuilder = CODLayerT::IndirectStubsManagerBuilderT;
+
+private:
+
+  using OwningObject = object::OwningBinary<object::ObjectFile>;
+
 public:
   using ModuleHandleT = unsigned;
 
@@ -145,12 +174,15 @@ public:
   createLazyCompileCallback(JITTargetAddress &RetAddr,
                             LLVMOrcLazyCompileCallbackFn Callback,
                             void *CallbackCtx) {
-    auto CCInfo = CCMgr->getCompileCallback();
-    CCInfo.setCompileAction([=]() -> JITTargetAddress {
-      return Callback(wrap(this), CallbackCtx);
-    });
-    RetAddr = CCInfo.getAddress();
-    return LLVMOrcErrSuccess;
+    if (auto CCInfoOrErr = CCMgr->getCompileCallback()) {
+      auto &CCInfo = *CCInfoOrErr;
+      CCInfo.setCompileAction([=]() -> JITTargetAddress {
+          return Callback(wrap(this), CallbackCtx);
+        });
+      RetAddr = CCInfo.getAddress();
+      return LLVMOrcErrSuccess;
+    } else
+      return mapError(CCInfoOrErr.takeError());
   }
 
   LLVMOrcErrorCode createIndirectStub(StringRef StubName,
@@ -263,6 +295,33 @@ public:
     return LLVMOrcErrSuccess;
   }
 
+  LLVMOrcErrorCode addObject(ModuleHandleT &RetHandle,
+                             std::unique_ptr<MemoryBuffer> ObjBuffer,
+                             LLVMOrcSymbolResolverFn ExternalResolver,
+                             void *ExternalResolverCtx) {
+    if (auto ObjOrErr =
+        object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef())) {
+      auto &Obj = *ObjOrErr;
+      auto OwningObj =
+        std::make_shared<OwningObject>(std::move(Obj), std::move(ObjBuffer));
+
+      // Create the resolver.
+      auto Resolver = createResolver(ExternalResolver, ExternalResolverCtx);
+
+      ModuleHandleT H;
+      if (auto HOrErr = ObjectLayer.addObject(std::move(OwningObj),
+                                              std::move(Resolver)))
+        H = createHandle(ObjectLayer, *HOrErr);
+      else
+        return mapError(HOrErr.takeError());
+
+      RetHandle = H;
+
+      return LLVMOrcErrSuccess;
+    } else
+      return mapError(ObjOrErr.takeError());
+  }
+
   JITSymbol findSymbol(const std::string &Name,
                                  bool ExportedSymbolsOnly) {
     if (auto Sym = IndirectStubsMgr->findStub(Name, ExportedSymbolsOnly))
@@ -298,17 +357,19 @@ public:
   const std::string &getErrorMessage() const { return ErrMsg; }
 
 private:
-  template <typename LayerT>
-  unsigned createHandle(LayerT &Layer, typename LayerT::ModuleHandleT Handle) {
+  template <typename LayerT, typename HandleT>
+  unsigned createHandle(LayerT &Layer, HandleT Handle) {
     unsigned NewHandle;
     if (!FreeHandleIndexes.empty()) {
       NewHandle = FreeHandleIndexes.back();
       FreeHandleIndexes.pop_back();
-      GenericHandles[NewHandle] = createGenericHandle(Layer, std::move(Handle));
+      GenericHandles[NewHandle] =
+        detail::createGenericHandle(Layer, std::move(Handle));
       return NewHandle;
     } else {
       NewHandle = GenericHandles.size();
-      GenericHandles.push_back(createGenericHandle(Layer, std::move(Handle)));
+      GenericHandles.push_back(
+        detail::createGenericHandle(Layer, std::move(Handle)));
     }
     return NewHandle;
   }
@@ -335,7 +396,7 @@ private:
   CompileLayerT CompileLayer;
   CODLayerT CODLayer;
 
-  std::vector<std::unique_ptr<GenericHandle>> GenericHandles;
+  std::vector<std::unique_ptr<detail::GenericHandle>> GenericHandles;
   std::vector<unsigned> FreeHandleIndexes;
 
   orc::LocalCXXRuntimeOverrides CXXRuntimeOverrides;
diff --git a/lib/ExecutionEngine/Orc/OrcError.cpp b/lib/ExecutionEngine/Orc/OrcError.cpp
index df2d320e0f7a..c218cb9a523c 100644
--- a/lib/ExecutionEngine/Orc/OrcError.cpp
+++ b/lib/ExecutionEngine/Orc/OrcError.cpp
@@ -54,6 +54,8 @@ public:
     case OrcErrorCode::UnknownErrorCodeFromRemote:
       return "Unknown error returned from remote RPC function "
              "(Use StringError to get error message)";
+    case OrcErrorCode::UnknownResourceHandle:
+      return "Unknown resource handle";
     }
     llvm_unreachable("Unhandled error code");
   }
diff --git a/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h b/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
index 346a40405ff1..1dc8d4ac7bc5 100644
--- a/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
+++ b/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
@@ -225,9 +225,9 @@ public:
   bool removeModule(Module *M) override {
     for (auto I = LocalModules.begin(), E = LocalModules.end(); I != E; ++I) {
       if (I->get() == M) {
-	ShouldDelete[M] = false;
-	LocalModules.erase(I);
-	return true;
+        ShouldDelete[M] = false;
+        LocalModules.erase(I);
+        return true;
       }
     }
     return false;
@@ -341,7 +341,7 @@ private:
 
     void operator()(RTDyldObjectLinkingLayerBase::ObjHandleT H,
                     const RTDyldObjectLinkingLayer::ObjectPtr &Obj,
-                    const LoadedObjectInfo &Info) const {
+                    const RuntimeDyld::LoadedObjectInfo &Info) const {
       M.UnfinalizedSections[H] = std::move(M.SectionsAllocatedSinceLastLoad);
       M.SectionsAllocatedSinceLastLoad = SectionAddrSet();
       M.MemMgr->notifyObjectLoaded(&M, *Obj->getBinary());
@@ -381,6 +381,12 @@ private:
   std::shared_ptr<JITSymbolResolver> ClientResolver;
   Mangler Mang;
 
+  // IMPORTANT: ShouldDelete *must* come before LocalModules: The shared_ptr
+  // delete blocks in LocalModules refer to the ShouldDelete map, so
+  // LocalModules needs to be destructed before ShouldDelete.
+  std::map<Module*, bool> ShouldDelete;
+  std::vector<std::shared_ptr<Module>> LocalModules;
+
   NotifyObjectLoadedT NotifyObjectLoaded;
   NotifyFinalizedT NotifyFinalized;
 
@@ -402,8 +408,6 @@ private:
   std::map<ObjectLayerT::ObjHandleT, SectionAddrSet, ObjHandleCompare>
       UnfinalizedSections;
 
-  std::map<Module*, bool> ShouldDelete;
-  std::vector<std::shared_ptr<Module>> LocalModules;
   std::vector<object::OwningBinary<object::Archive>> Archives;
 };