1 files changed, 61 insertions, 10 deletions
diff --git a/contrib/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h b/contrib/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h
index ce0864f..b9f7d6a 100644
--- a/contrib/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h
+++ b/contrib/llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h
@@ -1,4 +1,4 @@
-//===-- CompileUtils.h - Utilities for compiling IR in the JIT --*- C++ -*-===//
+//===- CompileUtils.h - Utilities for compiling IR in the JIT ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,24 +14,47 @@
 #ifndef LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
 #define LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H
 
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
 #include "llvm/IR/LegacyPassManager.h"
-#include "llvm/MC/MCContext.h"
+#include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
+#include <algorithm>
+#include <memory>
 
 namespace llvm {
+
+class MCContext;
+class Module;
+
 namespace orc {
 
 /// @brief Simple compile functor: Takes a single IR module and returns an
 ///        ObjectFile.
 class SimpleCompiler {
 public:
+
+  using CompileResult = object::OwningBinary<object::ObjectFile>;
+
   /// @brief Construct a simple compile functor with the given target.
-  SimpleCompiler(TargetMachine &TM) : TM(TM) {}
+  SimpleCompiler(TargetMachine &TM, ObjectCache *ObjCache = nullptr)
+    : TM(TM), ObjCache(ObjCache) {}
+
+  /// @brief Set an ObjectCache to query before compiling.
+  void setObjectCache(ObjectCache *NewCache) { ObjCache = NewCache; }
 
   /// @brief Compile a Module to an ObjectFile.
-  object::OwningBinary<object::ObjectFile> operator()(Module &M) const {
+  CompileResult operator()(Module &M) {
+    CompileResult CachedObject = tryToLoadFromObjectCache(M);
+    if (CachedObject.getBinary())
+      return CachedObject;
+
     SmallVector<char, 0> ObjBufferSV;
     raw_svector_ostream ObjStream(ObjBufferSV);
 
@@ -44,19 +67,47 @@ public:
         new ObjectMemoryBuffer(std::move(ObjBufferSV)));
     Expected<std::unique_ptr<object::ObjectFile>> Obj =
         object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
-    typedef object::OwningBinary<object::ObjectFile> OwningObj;
-    if (Obj)
-      return OwningObj(std::move(*Obj), std::move(ObjBuffer));
+    if (Obj) {
+      notifyObjectCompiled(M, *ObjBuffer);
+      return CompileResult(std::move(*Obj), std::move(ObjBuffer));
+    }
     // TODO: Actually report errors helpfully.
     consumeError(Obj.takeError());
-    return OwningObj(nullptr, nullptr);
+    return CompileResult(nullptr, nullptr);
   }
 
 private:
+
+  CompileResult tryToLoadFromObjectCache(const Module &M) {
+    if (!ObjCache)
+      return CompileResult();
+
+    std::unique_ptr<MemoryBuffer> ObjBuffer = ObjCache->getObject(&M);
+    if (!ObjBuffer)
+      return CompileResult();
+
+    Expected<std::unique_ptr<object::ObjectFile>> Obj =
+        object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
+    if (!Obj) {
+      // TODO: Actually report errors helpfully.
+      consumeError(Obj.takeError());
+      return CompileResult();
+    }
+
+    return CompileResult(std::move(*Obj), std::move(ObjBuffer));
+  }
+
+  void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer) {
+    if (ObjCache)
+      ObjCache->notifyObjectCompiled(&M, ObjBuffer.getMemBufferRef());
+  }
+
   TargetMachine &TM;
+  ObjectCache *ObjCache = nullptr;
 };
 
-} // End namespace orc.
-} // End namespace llvm.
+} // end namespace orc
+
+} // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_COMPILEUTILS_H