Add a cache for JITed object code.

We still need to generate the IR but if we can find,
a cache file created for the exact same IR we will load it and
skip instruction selection etc...

src/analysis/scoping_analysis.cpp

@@ -283,8 +283,12 @@ public:
         assert(usage);
         assert(ast);
 
+        // Sort the entries by name to make the order deterministic.
+        std::vector<InternedString> referenced_from_nested_sorted(usage->referenced_from_nested.begin(),
+                                                                  usage->referenced_from_nested.end());
+        std::sort(referenced_from_nested_sorted.begin(), referenced_from_nested_sorted.end());
         int i = 0;
-        for (auto& p : usage->referenced_from_nested) {
+        for (auto& p : referenced_from_nested_sorted) {
             closure_offsets[p] = i;
             i++;
         }

src/asm_writing/rewriter.cpp

@@ -1555,6 +1555,27 @@ void* extractSlowpathFunc(uint8_t* pp_addr) {
     return call_addr;
 }
 
+void setSlowpathFunc(uint8_t* pp_addr, void* func) {
+#ifndef NDEBUG
+    // mov $imm, %r11:
+    ASSERT(pp_addr[0] == 0x49, "%x", pp_addr[0]);
+    assert(pp_addr[1] == 0xbb);
+    // 8 bytes of the addr
+
+    // callq *%r11:
+    assert(pp_addr[10] == 0x41);
+    assert(pp_addr[11] == 0xff);
+    assert(pp_addr[12] == 0xd3);
+
+    int i = INITIAL_CALL_SIZE;
+    while (*(pp_addr + i) == 0x66 || *(pp_addr + i) == 0x0f || *(pp_addr + i) == 0x2e)
+        i++;
+    assert(*(pp_addr + i) == 0x90 || *(pp_addr + i) == 0x1f);
+#endif
+
+    *(void**)&pp_addr[2] = func;
+}
+
 std::pair<uint8_t*, uint8_t*> initializePatchpoint3(void* slowpath_func, uint8_t* start_addr, uint8_t* end_addr,
                                                     int scratch_offset, int scratch_size,
                                                     const std::unordered_set<int>& live_outs, SpillMap& remapped) {

src/asm_writing/rewriter.h

@@ -476,6 +476,7 @@ public:
 };
 
 void* extractSlowpathFunc(uint8_t* pp_addr);
+void setSlowpathFunc(uint8_t* pp_addr, void* func);
 
 struct GRCompare {
     bool operator()(assembler::GenericRegister gr1, assembler::GenericRegister gr2) const {

src/codegen/compvars.cpp

@@ -293,7 +293,8 @@ public:
 
         llvm::Value* cls_value = emitter.getBuilder()->CreateLoad(cls_ptr);
         assert(cls_value->getType() == g.llvm_class_type_ptr);
-        llvm::Value* rtn = emitter.getBuilder()->CreateICmpEQ(cls_value, embedConstantPtr(cls, g.llvm_class_type_ptr));
+        llvm::Value* rtn
+            = emitter.getBuilder()->CreateICmpEQ(cls_value, embedRelocatablePtr(cls, g.llvm_class_type_ptr));
         return rtn;
     }
 
@@ -367,8 +368,8 @@ public:
         }
 
         // We don't know the type so we have to check at runtime if __iter__ is implemented
-        llvm::Value* cmp = emitter.getBuilder()->CreateICmpNE(converted_iter_call->getValue(),
-                                                              embedConstantPtr(0, g.llvm_value_type_ptr));
+        llvm::Value* cmp
+            = emitter.getBuilder()->CreateICmpNE(converted_iter_call->getValue(), getNullPtr(g.llvm_value_type_ptr));
 
         llvm::BasicBlock* bb_has_iter = emitter.createBasicBlock("has_iter");
         bb_has_iter->moveAfter(emitter.currentBasicBlock());
@@ -529,19 +530,19 @@ static ConcreteCompilerVariable* _call(IREmitter& emitter, const OpInfo& info, l
     if (args.size() >= 1) {
         llvm_args.push_back(converted_args[0]->getValue());
     } else if (pass_keyword_names) {
-        llvm_args.push_back(embedConstantPtr(NULL, g.llvm_value_type_ptr));
+        llvm_args.push_back(getNullPtr(g.llvm_value_type_ptr));
     }
 
     if (args.size() >= 2) {
         llvm_args.push_back(converted_args[1]->getValue());
     } else if (pass_keyword_names) {
-        llvm_args.push_back(embedConstantPtr(NULL, g.llvm_value_type_ptr));
+        llvm_args.push_back(getNullPtr(g.llvm_value_type_ptr));
     }
 
     if (args.size() >= 3) {
         llvm_args.push_back(converted_args[2]->getValue());
     } else if (pass_keyword_names) {
-        llvm_args.push_back(embedConstantPtr(NULL, g.llvm_value_type_ptr));
+        llvm_args.push_back(getNullPtr(g.llvm_value_type_ptr));
     }
 
     llvm::Value* mallocsave = NULL;
@@ -569,10 +570,10 @@ static ConcreteCompilerVariable* _call(IREmitter& emitter, const OpInfo& info, l
         llvm_args.push_back(arg_array);
 
         if (pass_keyword_names)
-            llvm_args.push_back(embedConstantPtr(keyword_names, g.vector_ptr));
+            llvm_args.push_back(embedRelocatablePtr(keyword_names, g.vector_ptr));
     } else if (pass_keyword_names) {
-        llvm_args.push_back(embedConstantPtr(NULL, g.llvm_value_type_ptr->getPointerTo()));
-        llvm_args.push_back(embedConstantPtr(keyword_names, g.vector_ptr));
+        llvm_args.push_back(getNullPtr(g.llvm_value_type_ptr->getPointerTo()));
+        llvm_args.push_back(embedRelocatablePtr(keyword_names, g.vector_ptr));
     }
 
     // f->dump();
@@ -683,7 +684,7 @@ CompilerVariable* UnknownType::callattr(IREmitter& emitter, const OpInfo& info,
 
     std::vector<llvm::Value*> other_args;
     other_args.push_back(var->getValue());
-    other_args.push_back(embedConstantPtr(attr, g.llvm_str_type_ptr));
+    other_args.push_back(embedRelocatablePtr(attr, g.llvm_str_type_ptr));
     other_args.push_back(getConstantInt(flags_to_int.value, g.i8));
 
     llvm::Value* llvm_argspec = llvm::ConstantInt::get(g.i32, argspec.asInt(), false);
@@ -737,7 +738,7 @@ CompilerVariable* makeFunction(IREmitter& emitter, CLFunction* f, CompilerVariab
         convertedClosure = closure->makeConverted(emitter, closure->getConcreteType());
         closure_v = convertedClosure->getValue();
     } else {
-        closure_v = embedConstantPtr(nullptr, g.llvm_closure_type_ptr);
+        closure_v = getNullPtr(g.llvm_closure_type_ptr);
     }
 
     llvm::Value* scratch;
@@ -752,20 +753,20 @@ CompilerVariable* makeFunction(IREmitter& emitter, CLFunction* f, CompilerVariab
             i++;
         }
     } else {
-        scratch = embedConstantPtr(nullptr, g.llvm_value_type_ptr_ptr);
+        scratch = getNullPtr(g.llvm_value_type_ptr_ptr);
     }
 
     llvm::Value* isGenerator_v = llvm::ConstantInt::get(g.i1, isGenerator, false);
 
     assert(globals == NULL);
-    llvm::Value* globals_v = embedConstantPtr(nullptr, g.llvm_dict_type_ptr);
+    llvm::Value* globals_v = getNullPtr(g.llvm_dict_type_ptr);
 
     // We know this function call can't throw, so it's safe to use emitter.getBuilder()->CreateCall() rather than
     // emitter.createCall().
     llvm::Value* boxed = emitter.getBuilder()->CreateCall(
         g.funcs.boxCLFunction,
-        std::vector<llvm::Value*>{ embedConstantPtr(f, g.llvm_clfunction_type_ptr), closure_v, isGenerator_v, globals_v,
-                                   scratch, getConstantInt(defaults.size(), g.i64) });
+        std::vector<llvm::Value*>{ embedRelocatablePtr(f, g.llvm_clfunction_type_ptr), closure_v, isGenerator_v,
+                                   globals_v, scratch, getConstantInt(defaults.size(), g.i64) });
 
     if (convertedClosure)
         convertedClosure->decvref(emitter);
@@ -1339,7 +1340,7 @@ ConcreteCompilerVariable* makeFloat(double d) {
 
 ConcreteCompilerVariable* makeLong(IREmitter& emitter, std::string& n_long) {
     llvm::Value* v
-        = emitter.getBuilder()->CreateCall(g.funcs.createLong, embedConstantPtr(&n_long, g.llvm_str_type_ptr));
+        = emitter.getBuilder()->CreateCall(g.funcs.createLong, embedRelocatablePtr(&n_long, g.llvm_str_type_ptr));
     return new ConcreteCompilerVariable(LONG, v, true);
 }
 
@@ -1481,7 +1482,7 @@ public:
             ASSERT(rtattr, "%s.%s", debugName().c_str(), attr->c_str());
             if (rtattr->cls == function_cls) {
                 CompilerVariable* clattr = new ConcreteCompilerVariable(
-                    typeFromClass(function_cls), embedConstantPtr(rtattr, g.llvm_value_type_ptr), false);
+                    typeFromClass(function_cls), embedRelocatablePtr(rtattr, g.llvm_value_type_ptr), false);
                 return InstanceMethodType::makeIM(var, clattr);
             }
         }
@@ -1587,7 +1588,11 @@ public:
         }
         llvm::FunctionType* ft = llvm::FunctionType::get(cf->spec->rtn_type->llvmType(), arg_types, false);
 
-        llvm::Value* linked_function = embedConstantPtr(cf->code, ft->getPointerTo());
+        llvm::Value* linked_function;
+        if (cf->func) // for JITed functions we need to make the desination address relocatable.
+            linked_function = embedRelocatablePtr(cf->code, ft->getPointerTo());
+        else
+            linked_function = embedConstantPtr(cf->code, ft->getPointerTo());
 
         std::vector<CompilerVariable*> new_args;
         new_args.push_back(var);
@@ -1595,10 +1600,14 @@ public:
 
         for (int i = args.size() + 1; i < cl->num_args; i++) {
             // TODO should _call() be able to take llvm::Value's directly?
-            new_args.push_back(new ConcreteCompilerVariable(
-                UNKNOWN, embedConstantPtr(rtattr_func->defaults->elts[i - cl->num_args + cl->num_defaults],
-                                          g.llvm_value_type_ptr),
-                true));
+            auto value = rtattr_func->defaults->elts[i - cl->num_args + cl->num_defaults];
+            llvm::Value* llvm_value;
+            if (value)
+                llvm_value = embedRelocatablePtr(value, g.llvm_value_type_ptr);
+            else
+                llvm_value = getNullPtr(g.llvm_value_type_ptr);
+
+            new_args.push_back(new ConcreteCompilerVariable(UNKNOWN, llvm_value, true));
         }
 
         std::vector<llvm::Value*> other_args;
@@ -1873,8 +1882,8 @@ public:
 
     ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) override {
         assert(other_type == STR || other_type == UNKNOWN);
-        llvm::Value* boxed = emitter.getBuilder()->CreateCall(g.funcs.boxStringPtr,
-                                                              embedConstantPtr(var->getValue(), g.llvm_str_type_ptr));
+        llvm::Value* boxed = emitter.getBuilder()->CreateCall(
+            g.funcs.boxStringPtr, embedRelocatablePtr(var->getValue(), g.llvm_str_type_ptr));
         return new ConcreteCompilerVariable(other_type, boxed, true);
     }
 
@@ -1928,7 +1937,7 @@ public:
     }
 
     void serializeToFrame(VAR* var, std::vector<llvm::Value*>& stackmap_args) override {
-        stackmap_args.push_back(embedConstantPtr(var->getValue(), g.i8_ptr));
+        stackmap_args.push_back(embedRelocatablePtr(var->getValue(), g.i8_ptr));
     }
 
     Box* deserializeFromFrame(const FrameVals& vals) override {
@@ -1947,7 +1956,7 @@ CompilerVariable* makeStr(const std::string* s) {
 
 CompilerVariable* makeUnicode(IREmitter& emitter, const std::string* s) {
     llvm::Value* boxed
-        = emitter.getBuilder()->CreateCall(g.funcs.decodeUTF8StringPtr, embedConstantPtr(s, g.llvm_str_type_ptr));
+        = emitter.getBuilder()->CreateCall(g.funcs.decodeUTF8StringPtr, embedRelocatablePtr(s, g.llvm_str_type_ptr));
     return new ConcreteCompilerVariable(typeFromClass(unicode_cls), boxed, true);
 }
 

src/codegen/entry.cpp

@@ -16,6 +16,7 @@
 
 #include <cstdio>
 #include <iostream>
+#include <openssl/evp.h>
 #include <unordered_map>
 
 #include "llvm/Analysis/Passes.h"
@@ -31,6 +32,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Cloning.h"
@@ -118,54 +120,130 @@ static llvm::Module* loadStdlib() {
     return m;
 }
 
-class MyObjectCache : public llvm::ObjectCache {
+class PystonObjectCache : public llvm::ObjectCache {
 private:
-    bool loaded;
+    // Stream which calculates the SHA256 hash of the data writen to.
+    class HashOStream : public llvm::raw_ostream {
+        EVP_MD_CTX* md_ctx;
+
+        void write_impl(const char* ptr, size_t size) override { EVP_DigestUpdate(md_ctx, ptr, size); }
+        uint64_t current_pos() const override { return 0; }
+
+    public:
+        HashOStream() {
+            md_ctx = EVP_MD_CTX_create();
+            RELEASE_ASSERT(md_ctx, "");
+            int ret = EVP_DigestInit_ex(md_ctx, EVP_sha256(), NULL);
+            RELEASE_ASSERT(ret == 1, "");
+        }
+        ~HashOStream() { EVP_MD_CTX_destroy(md_ctx); }
+
+        std::string getHash() {
+            flush();
+            unsigned char md_value[EVP_MAX_MD_SIZE];
+            unsigned int md_len = 0;
+            int ret = EVP_DigestFinal_ex(md_ctx, md_value, &md_len);
+            RELEASE_ASSERT(ret == 1, "");
+
+            std::string str;
+            str.reserve(md_len * 2 + 1);
+            llvm::raw_string_ostream stream(str);
+            for (int i = 0; i < md_len; ++i)
+                stream.write_hex(md_value[i]);
+            return stream.str();
+        }
+    };
+
+
+    llvm::SmallString<128> cache_dir;
+    std::string module_identifier;
+    std::string hash_before_codegen;
 
 public:
-    MyObjectCache() : loaded(false) {}
+    PystonObjectCache() {
+        llvm::sys::fs::current_path(cache_dir);
+        llvm::sys::path::append(cache_dir, "pyston_object_cache");
+    }
+
 
 #if LLVMREV < 216002
-    virtual void notifyObjectCompiled(const llvm::Module* M, const llvm::MemoryBuffer* Obj) {}
+    virtual void notifyObjectCompiled(const llvm::Module* M, const llvm::MemoryBuffer* Obj)
 #else
-    virtual void notifyObjectCompiled(const llvm::Module* M, llvm::MemoryBufferRef Obj) {}
+    virtual void notifyObjectCompiled(const llvm::Module* M, llvm::MemoryBufferRef Obj)
 #endif
+    {
+        RELEASE_ASSERT(module_identifier == M->getModuleIdentifier(), "");
+        RELEASE_ASSERT(!hash_before_codegen.empty(), "");
+
+        llvm::SmallString<128> cache_file = cache_dir;
+        llvm::sys::path::append(cache_file, hash_before_codegen);
+        if (!llvm::sys::fs::exists(cache_dir.str()) && llvm::sys::fs::create_directory(cache_dir.str())) {
+            fprintf(stderr, "Unable to create cache directory\n");
+            return;
+        }
+        std::error_code error_code;
+        llvm::raw_fd_ostream IRObjectFile(cache_file.c_str(), error_code, llvm::sys::fs::F_RW);
+        RELEASE_ASSERT(!error_code, "");
+        IRObjectFile << Obj.getBuffer();
+    }
 
 #if LLVMREV < 215566
-    virtual llvm::MemoryBuffer* getObject(const llvm::Module* M){
+    virtual llvm::MemoryBuffer* getObject(const llvm::Module* M)
 #else
-    virtual std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* M) {
+    virtual std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* M)
 #endif
-        assert(!loaded);
-    loaded = true;
-    g.engine->setObjectCache(NULL);
-    std::unique_ptr<MyObjectCache> del_at_end(this);
+    {
+        static StatCounter jit_objectcache_hits("num_jit_objectcache_hits");
+        static StatCounter jit_objectcache_misses("num_jit_objectcache_misses");
+
+        module_identifier = M->getModuleIdentifier();
 
+        // Generate a hash for the module
+        HashOStream hash_stream;
+        M->print(hash_stream, 0);
+        hash_before_codegen = hash_stream.getHash();
+
+        llvm::SmallString<128> cache_file = cache_dir;
+        llvm::sys::path::append(cache_file, hash_before_codegen);
+        if (!llvm::sys::fs::exists(cache_file.str())) {
 #if 0
-            if (!USE_STRIPPED_STDLIB) {
-                stajt = STDLIB_CACHE_START;
-                size = (intptr_t)&STDLIB_CACHE_SIZE;
-            } else {
-                start = STRIPPED_STDLIB_CACHE_START;
-                size = (intptr_t)&STRIPPED_STDLIB_CACHE_SIZE;
-            }
-#else
-        RELEASE_ASSERT(0, "");
-        char* start = NULL;
-        intptr_t size = 0;
+            // This code helps with identifying why we got a cache miss for a file.
+            // - clear the cache directory
+            // - run pyston
+            // - run pyston a second time
+            // - Now look for "*_second" files in the cache directory and compare them to the "*_first" IR dump
+            std::string llvm_ir;
+            llvm::raw_string_ostream sstr(llvm_ir);
+            M->print(sstr, 0);
+            sstr.flush();
+
+            std::string filename = cache_dir.str().str() + "/" + module_identifier + "_first";
+            if (llvm::sys::fs::exists(filename))
+                filename = cache_dir.str().str() + "/" + module_identifier + "_second";
+            FILE* f = fopen(filename.c_str(), "wt");
+            fwrite(llvm_ir.c_str(), 1, llvm_ir.size(), f);
+            fclose(f);
 #endif
 
-    // Make sure the stdlib got linked in correctly; check the magic number at the beginning:
-    assert(start[0] == 0x7f);
-    assert(start[1] == 'E');
-    assert(start[2] == 'L');
-    assert(start[3] == 'F');
+            // This file isn't in our cache
+            jit_objectcache_misses.log();
+            return NULL;
+        }
 
-    assert(size > 0 && size < 1 << 30); // make sure the size is being loaded correctly
+        auto rtn = llvm::MemoryBuffer::getFile(cache_file.str(), -1, false);
+        if (!rtn) {
+            jit_objectcache_misses.log();
+            return NULL;
+        }
 
-    llvm::StringRef data(start, size);
-    return llvm::MemoryBuffer::getMemBufferCopy(data, "");
-}
+        jit_objectcache_hits.log();
+
+        // MCJIT will want to write into this buffer, and we don't want that
+        // because the file has probably just been mmapped.  Instead we make
+        // a copy.  The filed-based buffer will be released when it goes
+        // out of scope.
+        return llvm::MemoryBuffer::getMemBufferCopy((*rtn)->getBuffer());
+    }
 };
 
 static void handle_sigusr1(int signum) {
@@ -223,7 +301,8 @@ void initCodegen() {
     g.engine = eb.create(g.tm);
     assert(g.engine && "engine creation failed?");
 
-    // g.engine->setObjectCache(new MyObjectCache());
+    if (ENABLE_JIT_OBJECT_CACHE)
+        g.engine->setObjectCache(new PystonObjectCache());
 
     g.i1 = llvm::Type::getInt1Ty(g.context);
     g.i8 = llvm::Type::getInt8Ty(g.context);

src/codegen/irgen.cpp

@@ -541,7 +541,7 @@ static void emitBBs(IRGenState* irstate, TypeAnalysis* types, const OSREntryDesc
                 llvm::BasicBlock* reopt_bb = llvm::BasicBlock::Create(g.context, "reopt", irstate->getLLVMFunction());
                 emitter->getBuilder()->SetInsertPoint(preentry_bb);
 
-                llvm::Value* call_count_ptr = embedConstantPtr(&cf->times_called, g.i64->getPointerTo());
+                llvm::Value* call_count_ptr = embedRelocatablePtr(&cf->times_called, g.i64->getPointerTo());
                 llvm::Value* cur_call_count = emitter->getBuilder()->CreateLoad(call_count_ptr);
                 llvm::Value* new_call_count
                     = emitter->getBuilder()->CreateAdd(cur_call_count, getConstantInt(1, g.i64));
@@ -569,7 +569,7 @@ static void emitBBs(IRGenState* irstate, TypeAnalysis* types, const OSREntryDesc
                 emitter->getBuilder()->SetInsertPoint(reopt_bb);
                 // emitter->getBuilder()->CreateCall(g.funcs.my_assert, getConstantInt(0, g.i1));
                 llvm::Value* r = emitter->getBuilder()->CreateCall(g.funcs.reoptCompiledFunc,
-                                                                   embedConstantPtr(cf, g.i8->getPointerTo()));
+                                                                   embedRelocatablePtr(cf, g.i8->getPointerTo()));
                 assert(r);
                 assert(r->getType() == g.i8->getPointerTo());
 
@@ -739,6 +739,7 @@ static void emitBBs(IRGenState* irstate, TypeAnalysis* types, const OSREntryDesc
                 // NB. This is where most `typical' phi nodes get added.
                 // And go through and add phi nodes:
                 ConcreteSymbolTable* pred_st = phi_ending_symbol_tables[pred];
+
                 for (auto it = pred_st->begin(); it != pred_st->end(); ++it) {
                     InternedString name = it->first;
                     ConcreteCompilerVariable* cv = it->second; // incoming CCV from predecessor block
@@ -959,6 +960,9 @@ CompiledFunction* doCompile(SourceInfo* source, ParamNames* param_names, const O
         source->cfg->print();
 
     assert(g.cur_module == NULL);
+
+    clearRelocatableSymsMap();
+
     std::string name = getUniqueFunctionName(nameprefix, effort, entry_descriptor);
     g.cur_module = new llvm::Module(name, g.context);
 #if LLVMREV < 217070 // not sure if this is the right rev
@@ -1010,7 +1014,7 @@ CompiledFunction* doCompile(SourceInfo* source, ParamNames* param_names, const O
 
 
     CompiledFunction* cf
-        = new CompiledFunction(NULL, spec, (effort == EffortLevel::INTERPRETED), NULL, NULL, effort, entry_descriptor);
+        = new CompiledFunction(NULL, spec, (effort == EffortLevel::INTERPRETED), NULL, effort, entry_descriptor);
 
     llvm::FunctionType* ft = llvm::FunctionType::get(cf->getReturnType()->llvmType(), llvm_arg_types, false /*vararg*/);
 

src/codegen/irgen/hooks.cpp

@@ -156,8 +156,6 @@ static void compileIR(CompiledFunction* cf, EffortLevel effort) {
         assert(compiled);
         ASSERT(compiled == cf->code, "cf->code should have gotten filled in");
 
-        cf->llvm_code = embedConstantPtr(compiled, cf->func->getType());
-
         long us = _t.end();
         static StatCounter us_jitting("us_compiling_jitting");
         us_jitting.log(us);
@@ -243,7 +241,7 @@ CompiledFunction* compileFunction(CLFunction* f, FunctionSpecialization* spec, E
     CompiledFunction* cf = 0;
     if (effort == EffortLevel::INTERPRETED) {
         assert(!entry_descriptor);
-        cf = new CompiledFunction(0, spec, true, NULL, NULL, effort, 0);
+        cf = new CompiledFunction(0, spec, true, NULL, effort, 0);
     } else {
         cf = doCompile(source, &f->param_names, entry_descriptor, effort, spec, name);
         compileIR(cf, effort);
@@ -651,21 +649,6 @@ void addRTFunction(CLFunction* cl_f, void* f, ConcreteCompilerType* rtn_type,
 #endif
 
     FunctionSpecialization* spec = new FunctionSpecialization(processType(rtn_type), arg_types);
-
-    std::vector<llvm::Type*> llvm_arg_types;
-    int npassed_args = arg_types.size();
-    assert(npassed_args == cl_f->numReceivedArgs());
-    for (int i = 0; i < npassed_args; i++) {
-        if (i == 3) {
-            llvm_arg_types.push_back(g.i8_ptr->getPointerTo());
-            break;
-        }
-        llvm_arg_types.push_back(arg_types[i]->llvmType());
-    }
-
-    llvm::FunctionType* ft = llvm::FunctionType::get(g.llvm_value_type_ptr, llvm_arg_types, false);
-
-    cl_f->addVersion(new CompiledFunction(NULL, spec, false, f, embedConstantPtr(f, ft->getPointerTo()),
-                                          EffortLevel::MAXIMAL, NULL));
+    cl_f->addVersion(new CompiledFunction(NULL, spec, false, f, EffortLevel::MAXIMAL, NULL));
 }
 }

src/codegen/irgen/util.cpp

@@ -80,7 +80,7 @@ llvm::Constant* getStringConstantPtr(const std::string& str) {
         strings[str] = buf;
         c = buf;
     }
-    return embedConstantPtr(c, g.i8->getPointerTo());
+    return embedRelocatablePtr(c, g.i8->getPointerTo());
 }
 
 // Returns a llvm::Constant char* to a global string constant
@@ -92,6 +92,33 @@ llvm::Constant* getStringConstantPtr(const char* str) {
 // to some associated compiler-level data structure.
 // It's slightly easier to emit them as integers (there are primitive integer constants but not pointer constants),
 // but doing it this way makes it clearer what's going on.
+
+static llvm::StringMap<const void*> relocatable_syms;
+
+void clearRelocatableSymsMap() {
+    relocatable_syms.clear();
+}
+
+const void* getValueOfRelocatableSym(const std::string& str) {
+    auto it = relocatable_syms.find(str);
+    if (it != relocatable_syms.end())
+        return it->second;
+    return NULL;
+}
+
+llvm::Constant* embedRelocatablePtr(const void* addr, llvm::Type* type) {
+    assert(addr);
+
+    if (!ENABLE_JIT_OBJECT_CACHE)
+        return embedConstantPtr(addr, type);
+
+    std::string name = (llvm::Twine("c") + llvm::Twine(relocatable_syms.size())).str();
+    relocatable_syms[name] = addr;
+
+    llvm::Type* var_type = type->getPointerElementType();
+    return new llvm::GlobalVariable(*g.cur_module, var_type, true, llvm::GlobalVariable::ExternalLinkage, 0, name);
+}
+
 llvm::Constant* embedConstantPtr(const void* addr, llvm::Type* type) {
     assert(type);
     llvm::Constant* int_val = llvm::ConstantInt::get(g.i64, reinterpret_cast<uintptr_t>(addr), false);
@@ -99,6 +126,11 @@ llvm::Constant* embedConstantPtr(const void* addr, llvm::Type* type) {
     return ptr_val;
 }
 
+llvm::Constant* getNullPtr(llvm::Type* t) {
+    assert(llvm::isa<llvm::PointerType>(t));
+    return llvm::ConstantPointerNull::get(llvm::cast<llvm::PointerType>(t));
+}
+
 llvm::Constant* getConstantInt(int64_t n, llvm::Type* t) {
     return llvm::ConstantInt::get(t, n);
 }

src/codegen/irgen/util.h

@@ -27,10 +27,15 @@ namespace pyston {
 
 llvm::Constant* getStringConstantPtr(const std::string& str);
 llvm::Constant* getStringConstantPtr(const char* str);
+llvm::Constant* embedRelocatablePtr(const void* addr, llvm::Type*);
 llvm::Constant* embedConstantPtr(const void* addr, llvm::Type*);
 llvm::Constant* getConstantInt(int64_t val);
 llvm::Constant* getConstantDouble(double val);
 llvm::Constant* getConstantInt(int64_t val, llvm::Type*);
+llvm::Constant* getNullPtr(llvm::Type* t);
+
+void clearRelocatableSymsMap();
+const void* getValueOfRelocatableSym(const std::string& str);
 
 void dumpPrettyIR(llvm::Function* f);
 }

src/codegen/memmgr.cpp

@@ -20,6 +20,7 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Memory.h"
 
+#include "codegen/irgen/util.h"
 #include "core/common.h"
 #include "core/stats.h"
 #include "core/util.h"
@@ -206,7 +207,11 @@ void PystonMemoryManager::invalidateInstructionCache() {
 }
 
 uint64_t PystonMemoryManager::getSymbolAddress(const std::string& name) {
-    uint64_t base = RTDyldMemoryManager::getSymbolAddress(name);
+    uint64_t base = (uint64_t)getValueOfRelocatableSym(name);
+    if (base)
+        return base;
+
+    base = RTDyldMemoryManager::getSymbolAddress(name);
     if (base)
         return base;
 
@@ -214,7 +219,7 @@ uint64_t PystonMemoryManager::getSymbolAddress(const std::string& name) {
         return getSymbolAddress(".L" + name);
     }
 
-    printf("getSymbolAddress(%s); %lx\n", name.c_str(), base);
+    RELEASE_ASSERT(0, "Could not find sym: %s", name.c_str());
     return 0;
 }
 

src/codegen/patchpoints.cpp

@@ -20,6 +20,7 @@
 #include "asm_writing/icinfo.h"
 #include "asm_writing/rewriter.h"
 #include "codegen/compvars.h"
+#include "codegen/irgen/util.h"
 #include "codegen/stackmaps.h"
 #include "core/common.h"
 #include "core/options.h"
@@ -41,7 +42,7 @@ int ICSetupInfo::totalSize() const {
     return num_slots * slot_size + call_size;
 }
 
-static std::vector<PatchpointInfo*> new_patchpoints;
+static std::vector<std::pair<PatchpointInfo*, void* /* addr of func to call */>> new_patchpoints;
 
 ICSetupInfo* ICSetupInfo::initialize(bool has_return_value, int num_slots, int slot_size, ICType type,
                                      TypeRecorder* type_recorder) {
@@ -165,9 +166,12 @@ void processStackmap(CompiledFunction* cf, StackMap* stackmap) {
         const StackMap::StackSizeRecord& stack_size_record = stackmap->stack_size_records[0];
         int stack_size = stack_size_record.stack_size;
 
-        PatchpointInfo* pp = reinterpret_cast<PatchpointInfo*>(r->id);
+
+        RELEASE_ASSERT(new_patchpoints.size() > r->id, "");
+        PatchpointInfo* pp = new_patchpoints[r->id].first;
         assert(pp);
 
+        void* dst_func = new_patchpoints[r->id].second;
         if (VERBOSITY() >= 2) {
             printf("Processing pp %ld; [%d, %d)\n", reinterpret_cast<int64_t>(pp), r->offset,
                    r->offset + pp->patchpointSize());
@@ -183,6 +187,9 @@ void processStackmap(CompiledFunction* cf, StackMap* stackmap) {
         uint8_t* start_addr = (uint8_t*)pp->parentFunction()->code + r->offset;
         uint8_t* end_addr = start_addr + pp->patchpointSize();
 
+        if (ENABLE_JIT_OBJECT_CACHE)
+            setSlowpathFunc(start_addr, dst_func);
+
         // TODO shouldn't have to do it this way
         void* slowpath_func = extractSlowpathFunc(start_addr);
 
@@ -270,7 +277,8 @@ void processStackmap(CompiledFunction* cf, StackMap* stackmap) {
         cf->ics.push_back(icinfo.release());
     }
 
-    for (PatchpointInfo* pp : new_patchpoints) {
+    for (auto& e : new_patchpoints) {
+        PatchpointInfo* pp = e.first;
         const ICSetupInfo* ic = pp->getICInfo();
         if (ic)
             delete ic;
@@ -279,13 +287,14 @@ void processStackmap(CompiledFunction* cf, StackMap* stackmap) {
     new_patchpoints.clear();
 }
 
-PatchpointInfo* PatchpointInfo::create(CompiledFunction* parent_cf, const ICSetupInfo* icinfo,
-                                       int num_ic_stackmap_args) {
+PatchpointInfo* PatchpointInfo::create(CompiledFunction* parent_cf, const ICSetupInfo* icinfo, int num_ic_stackmap_args,
+                                       void* func_addr) {
     if (icinfo == NULL)
         assert(num_ic_stackmap_args == 0);
 
     auto* r = new PatchpointInfo(parent_cf, icinfo, num_ic_stackmap_args);
-    new_patchpoints.push_back(r);
+    r->id = new_patchpoints.size();
+    new_patchpoints.push_back(std::make_pair(r, func_addr));
     return r;
 }
 

src/codegen/patchpoints.h

@@ -53,10 +53,12 @@ private:
     int num_frame_stackmap_args;
 
     std::vector<FrameVarInfo> frame_vars;
+    unsigned int id;
 
     PatchpointInfo(CompiledFunction* parent_cf, const ICSetupInfo* icinfo, int num_ic_stackmap_args)
-        : parent_cf(parent_cf), icinfo(icinfo), num_ic_stackmap_args(num_ic_stackmap_args),
-          num_frame_stackmap_args(-1) {}
+        : parent_cf(parent_cf), icinfo(icinfo), num_ic_stackmap_args(num_ic_stackmap_args), num_frame_stackmap_args(-1),
+          id(0) {}
+
 
 public:
     const ICSetupInfo* getICInfo() { return icinfo; }
@@ -84,11 +86,14 @@ public:
         return num_frame_stackmap_args;
     }
 
+    unsigned int getId() const { return id; }
+
     void parseLocationMap(StackMap::Record* r, LocationMap* map);
 
     int totalStackmapArgs() { return frameStackmapArgsStart() + numFrameStackmapArgs(); }
 
-    static PatchpointInfo* create(CompiledFunction* parent_cf, const ICSetupInfo* icinfo, int num_ic_stackmap_args);
+    static PatchpointInfo* create(CompiledFunction* parent_cf, const ICSetupInfo* icinfo, int num_ic_stackmap_args,
+                                  void* func_addr);
 };
 
 class ICSetupInfo {

src/codegen/runtime_hooks.cpp

@@ -261,7 +261,6 @@ void initGlobalFuncs(GlobalState& g) {
     g.funcs.reoptCompiledFunc = addFunc((void*)reoptCompiledFunc, g.i8_ptr, g.i8_ptr);
     g.funcs.compilePartialFunc = addFunc((void*)compilePartialFunc, g.i8_ptr, g.i8_ptr);
 
-    GET(__cxa_begin_catch);
     g.funcs.__cxa_end_catch = addFunc((void*)__cxa_end_catch, g.void_);
     GET(raise0);
     GET(raise3);

src/codegen/runtime_hooks.h

@@ -49,7 +49,7 @@ struct GlobalFuncs {
     llvm::Value* exec;
     llvm::Value* boxedLocalsSet, *boxedLocalsGet, *boxedLocalsDel;
 
-    llvm::Value* __cxa_begin_catch, *__cxa_end_catch;
+    llvm::Value* __cxa_end_catch;
     llvm::Value* raise0, *raise3;
     llvm::Value* deopt;
 

src/core/ast.cpp

@@ -24,7 +24,7 @@
 
 namespace pyston {
 
-#ifndef NDEBUG
+#ifdef DEBUG_LINE_NUMBERS
 int AST::next_lineno = 100000;
 
 AST::AST(AST_TYPE::AST_TYPE type) : type(type), lineno(++next_lineno) {

src/core/ast.h

@@ -154,16 +154,17 @@ public:
 
     virtual void accept(ASTVisitor* v) = 0;
 
-#ifndef NDEBUG
+// #define DEBUG_LINE_NUMBERS 1
+#ifdef DEBUG_LINE_NUMBERS
 private:
-    // In debug mode, initialize lineno to something unique, so that if we see something ridiculous
+    // Initialize lineno to something unique, so that if we see something ridiculous
     // appear in the traceback, we can isolate the allocation which created it.
     static int next_lineno;
 
 public:
     AST(AST_TYPE::AST_TYPE type);
 #else
-    AST(AST_TYPE::AST_TYPE type) : type(type) {}
+    AST(AST_TYPE::AST_TYPE type) : type(type), lineno(0), col_offset(0) {}
 #endif
     AST(AST_TYPE::AST_TYPE type, uint32_t lineno, uint32_t col_offset = 0)
         : type(type), lineno(lineno), col_offset(col_offset) {}

src/core/cfg.cpp

@@ -172,6 +172,8 @@ private:
     std::vector<ContInfo> continuations;
     std::vector<ExcBlockInfo> exc_handlers;
 
+    unsigned int next_var_index = 0;
+
     friend CFG* computeCFG(SourceInfo* source, std::vector<AST_stmt*> body);
 
 public:
@@ -196,6 +198,11 @@ private:
         return source->getInternedStrings().get(std::forward<T>(s));
     }
 
+    InternedString createUniqueName(llvm::Twine prefix) {
+        std::string name = (prefix + llvm::Twine(next_var_index++)).str();
+        return source->getInternedStrings().get(std::move(name));
+    }
+
     AST_Name* makeName(InternedString id, AST_TYPE::AST_TYPE ctx_type, int lineno, int col_offset = 0) {
         AST_Name* name = new AST_Name(id, ctx_type, lineno, col_offset);
         return name;
@@ -600,36 +607,14 @@ private:
         return stmt;
     }
 
-    InternedString nodeName(AST* node) {
-        char buf[40];
-        int bytes = snprintf(buf, 40, "#%p", node);
-        assert(bytes < 40); // double-check
-// Uncomment this line to check to make sure we never reuse the same nodeName() accidentally.
-// This check is potentially too expensive for even debug mode, since it never frees any memory.
-// #define VALIDATE_FAKE_NAMES
-#ifdef VALIDATE_FAKE_NAMES
-        std::string r(buf);
-        static std::unordered_set<std::string> made;
-        assert(made.count(r) == 0);
-        made.insert(r);
-        return internString(std::move(r));
-#else
-        return internString(buf);
-#endif
-    }
+    InternedString nodeName(AST* node) { return createUniqueName("#"); }
 
     InternedString nodeName(AST* node, const std::string& suffix) {
-        char buf[50];
-        int bytes = snprintf(buf, 50, "#%p_%s", node, suffix.c_str());
-        assert(bytes < 50); // double-check
-        return internString(std::string(buf));
+        return createUniqueName(llvm::Twine("#") + suffix + "_");
     }
 
     InternedString nodeName(AST* node, const std::string& suffix, int idx) {
-        char buf[50];
-        int bytes = snprintf(buf, 50, "#%p_%s_%d", node, suffix.c_str(), idx);
-        assert(bytes < 50); // double-check
-        return internString(std::string(buf));
+        return createUniqueName(llvm::Twine("#") + suffix + "_" + llvm::Twine(idx) + "_");
     }
 
     AST_expr* remapAttribute(AST_Attribute* node) {
@@ -2005,9 +1990,7 @@ public:
         AST_LangPrimitive* iter_call = new AST_LangPrimitive(AST_LangPrimitive::GET_ITER);
         iter_call->args.push_back(remapped_iter);
 
-        char itername_buf[80];
-        snprintf(itername_buf, 80, "#iter_%p", node);
-        InternedString itername = internString(itername_buf);
+        InternedString itername = createUniqueName("#iter_");
         pushAssign(itername, iter_call);
 
         AST_expr* next_attr = makeLoadAttribute(makeLoad(itername, node), internString("next"), true);

src/core/options.cpp

@@ -71,6 +71,7 @@ bool ENABLE_REOPT = 1 && _GLOBAL_ENABLE;
 bool ENABLE_PYSTON_PASSES = 1 && _GLOBAL_ENABLE;
 bool ENABLE_TYPE_FEEDBACK = 1 && _GLOBAL_ENABLE;
 bool ENABLE_RUNTIME_ICS = 1 && _GLOBAL_ENABLE;
+bool ENABLE_JIT_OBJECT_CACHE = 1 && _GLOBAL_ENABLE;
 
 bool ENABLE_FRAME_INTROSPECTION = 1;
 bool BOOLS_AS_I64 = ENABLE_FRAME_INTROSPECTION;

src/core/options.h

@@ -42,7 +42,7 @@ extern bool SHOW_DISASM, FORCE_INTERPRETER, FORCE_OPTIMIZE, PROFILE, DUMPJIT, TR
 extern bool ENABLE_ICS, ENABLE_ICGENERICS, ENABLE_ICGETITEMS, ENABLE_ICSETITEMS, ENABLE_ICDELITEMS, ENABLE_ICBINEXPS,
     ENABLE_ICNONZEROS, ENABLE_ICCALLSITES, ENABLE_ICSETATTRS, ENABLE_ICGETATTRS, ENALBE_ICDELATTRS, ENABLE_ICGETGLOBALS,
     ENABLE_SPECULATION, ENABLE_OSR, ENABLE_LLVMOPTS, ENABLE_INLINING, ENABLE_REOPT, ENABLE_PYSTON_PASSES,
-    ENABLE_TYPE_FEEDBACK, ENABLE_FRAME_INTROSPECTION, ENABLE_RUNTIME_ICS;
+    ENABLE_TYPE_FEEDBACK, ENABLE_FRAME_INTROSPECTION, ENABLE_RUNTIME_ICS, ENABLE_JIT_OBJECT_CACHE;
 
 // Due to a temporary LLVM limitation, represent bools as i64's instead of i1's.
 extern bool BOOLS_AS_I64;

src/core/types.h

@@ -188,7 +188,6 @@ public:
         uintptr_t code_start;
     };
     int code_size;
-    llvm::Value* llvm_code; // the llvm callable.
 
     EffortLevel effort;
 
@@ -200,10 +199,9 @@ public:
     std::vector<ICInfo*> ics;
 
     CompiledFunction(llvm::Function* func, FunctionSpecialization* spec, bool is_interpreted, void* code,
-                     llvm::Value* llvm_code, EffortLevel effort, const OSREntryDescriptor* entry_descriptor)
+                     EffortLevel effort, const OSREntryDescriptor* entry_descriptor)
         : clfunc(NULL), func(func), spec(spec), entry_descriptor(entry_descriptor), is_interpreted(is_interpreted),
-          code(code), llvm_code(llvm_code), effort(effort), times_called(0), times_speculation_failed(0),
-          location_map(nullptr) {
+          code(code), effort(effort), times_called(0), times_speculation_failed(0), location_map(nullptr) {
         assert((spec != NULL) + (entry_descriptor != NULL) == 1);
     }
 
@@ -307,7 +305,6 @@ public:
         assert((compiled->spec != NULL) + (compiled->entry_descriptor != NULL) == 1);
         assert(compiled->clfunc == NULL);
         assert(compiled->is_interpreted == (compiled->code == NULL));
-        assert(compiled->is_interpreted == (compiled->llvm_code == NULL));
         compiled->clfunc = this;
 
         if (compiled->entry_descriptor == NULL) {