object cache: hash IR before doing running any opt passes

This lets us to skip running the opt passes when we find a cached object file.
This has the disadvantage that opt passes are not allowed to call embedRelocatablePtr()
but has the advantage that we could do more costly optimizations in the future without hurting the perf on the second run.

src/codegen/codegen.h

@@ -31,6 +31,8 @@ class TargetMachine;
 
 namespace pyston {
 
+class PystonObjectCache;
+
 class FunctionAddressRegistry {
 private:
     struct FuncInfo {
@@ -62,6 +64,7 @@ struct GlobalState {
     CompiledFunction* cur_cf;
     llvm::TargetMachine* tm;
     llvm::ExecutionEngine* engine;
+    PystonObjectCache* object_cache;
 
     std::vector<llvm::JITEventListener*> jit_listeners;
 

src/codegen/irgen.cpp

@@ -20,6 +20,7 @@
 #include <stdint.h>
 
 #include "llvm/Analysis/Passes.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
@@ -1120,8 +1121,18 @@ CompiledFunction* doCompile(CLFunction* clfunc, SourceInfo* source, ParamNames*
     static StatCounter us_irgen("us_compiling_irgen");
     us_irgen.log(irgen_us);
 
-    if (ENABLE_LLVMOPTS)
-        optimizeIR(f, effort);
+
+    // Calculate the module hash before doing any optimizations.
+    // This has the advantage that we can skip running the opt passes when we have cached object file
+    // but the disadvantage that optimizations are not allowed to add new symbolic constants...
+    if (ENABLE_JIT_OBJECT_CACHE) {
+        g.object_cache->calculateModuleHash(g.cur_module, effort);
+        if (ENABLE_LLVMOPTS && !g.object_cache->haveCacheFileForHash())
+            optimizeIR(f, effort);
+    } else {
+        if (ENABLE_LLVMOPTS)
+            optimizeIR(f, effort);
+    }
 
     g.cur_module = NULL;
 

src/codegen/irgen.h

@@ -15,6 +15,8 @@
 #ifndef PYSTON_CODEGEN_IRGEN_H
 #define PYSTON_CODEGEN_IRGEN_H
 
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Intrinsics.h"
@@ -150,6 +152,35 @@ public:
 
     ExceptionStyle preferredExceptionStyle() const { return unw_info.preferredExceptionStyle(); }
 };
+
+
+class PystonObjectCache : public llvm::ObjectCache {
+private:
+    llvm::SmallString<128> cache_dir;
+    std::string module_identifier;
+    std::string hash_before_codegen;
+
+public:
+    PystonObjectCache();
+
+
+#if LLVMREV < 216002
+    virtual void notifyObjectCompiled(const llvm::Module* M, const llvm::MemoryBuffer* Obj);
+#else
+    virtual void notifyObjectCompiled(const llvm::Module* M, llvm::MemoryBufferRef Obj);
+#endif
+
+#if LLVMREV < 215566
+    virtual llvm::MemoryBuffer* getObject(const llvm::Module* M);
+#else
+    virtual std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* M);
+#endif
+
+    void cleanupCacheDirectory();
+
+    void calculateModuleHash(const llvm::Module* M, EffortLevel effort);
+    bool haveCacheFileForHash();
+};
 }
 
 #endif