JIT class: the EVM JIT facade.

The JIT class added, future public EVM JIT library interface. Currently it supports queries about EVM code status.

CMakeLists.txt

@@ -33,6 +33,8 @@ else()
 	link_directories(/usr/lib/llvm-3.5/lib)
 endif()
 
+get_filename_component(EVMJIT_INCLUDE_DIR include ABSOLUTE)
+
 add_subdirectory(libevmjit)
 
 if(EVMJIT_CPP)

include/evmjit/DataTypes.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+namespace dev
+{
+namespace evmjit
+{
+
+struct h256
+{
+	uint64_t words[4];
+};
+
+inline bool operator==(h256 _h1, h256 _h2)
+{
+	return 	_h1.words[0] == _h2.words[0] &&
+			_h1.words[1] == _h2.words[1] &&
+			_h1.words[2] == _h2.words[2] &&
+			_h1.words[3] == _h2.words[3];
+}
+
+/// Representation of 256-bit value binary compatible with LLVM i256
+struct i256
+{
+	uint64_t a = 0;
+	uint64_t b = 0;
+	uint64_t c = 0;
+	uint64_t d = 0;
+
+	i256() = default;
+	i256(h256 _h)
+	{
+		a = _h.words[0];
+		b = _h.words[1];
+		c = _h.words[2];
+		d = _h.words[3];
+	}
+};
+
+}
+}
+
+namespace std
+{
+template<> struct hash<dev::evmjit::h256>
+{
+	size_t operator()(dev::evmjit::h256 const& _h) const
+	{
+		/// This implementation expects the argument to be a full 256-bit Keccak hash.
+		/// It does nothing more than returning a slice of the input hash.
+		return static_cast<size_t>(_h.words[0]);
+	};
+};
+}

include/evmjit/JIT.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "evmjit/DataTypes.h"
+
+namespace dev
+{
+namespace eth
+{
+namespace jit
+{
+	class ExecutionEngine;
+}
+}
+
+namespace evmjit
+{
+
+class JIT
+{
+public:
+
+	/// Ask JIT if the EVM code is ready for execution.
+	/// Returns `true` if the EVM code has been compiled and loaded into memory.
+	/// In this case the code can be executed without overhead.
+	/// \param _codeHash	The Keccak hash of the EVM code.
+	static bool isCodeReady(h256 _codeHash);
+
+private:
+	friend class dev::eth::jit::ExecutionEngine;
+
+	static void* getCode(h256 _codeHash);
+	static void mapCode(h256 _codeHash, void* _funcAddr);
+};
+
+}
+}

libevmjit-cpp/CMakeLists.txt

@@ -19,6 +19,7 @@ add_library(${TARGET_NAME} STATIC ${SOURCES})
 set_property(TARGET ${TARGET_NAME} PROPERTY FOLDER "libs")
 
 include_directories(../..)
+include_directories(${EVMJIT_INCLUDE_DIR})
 include_directories(${LLVM_INCLUDE_DIRS})
 include_directories(${Boost_INCLUDE_DIRS})
 

libevmjit-cpp/Env.cpp

@@ -3,6 +3,7 @@
 #include <libdevcrypto/SHA3.h>
 #include <libevmcore/Params.h>
 #include <libevm/ExtVMFace.h>
+#include <evmjit/DataTypes.h>
 
 #include "Utils.h"
 
@@ -16,7 +17,7 @@ extern "C"
 
 	using namespace dev;
 	using namespace dev::eth;
-	using jit::i256;
+	using evmjit::i256;
 
 	EXPORT void env_sload(ExtVMFace* _env, i256* _index, i256* o_value)
 	{

libevmjit-cpp/Utils.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <evmjit/libevmjit/Common.h>
+#include <evmjit/DataTypes.h>
 
 namespace dev
 {
 namespace eth
 {
 
-inline u256 llvm2eth(jit::i256 _i)
+inline u256 llvm2eth(evmjit::i256 _i)
 {
 	u256 u = 0;
 	u |= _i.d;
@@ -20,9 +20,9 @@ inline u256 llvm2eth(jit::i256 _i)
 	return u;
 }
 
-inline jit::i256 eth2llvm(u256 _u)
+inline evmjit::i256 eth2llvm(u256 _u)
 {
-	jit::i256 i;
+	evmjit::i256 i;
 	u256 mask = 0xFFFFFFFFFFFFFFFF;
 	i.a = static_cast<uint64_t>(_u & mask);
 	_u >>= 64;
@@ -34,5 +34,11 @@ inline jit::i256 eth2llvm(u256 _u)
 	return i;
 }
 
+inline evmjit::h256 eth2llvm(h256 _u)
+{
+	/// Just directly copies memory
+	return *(evmjit::h256*)&_u;
+}
+
 }
 }

libevmjit/CMakeLists.txt

@@ -8,6 +8,7 @@ set(SOURCES
     Common.h
     Compiler.cpp		Compiler.h
     CompilerHelper.cpp	CompilerHelper.h
+    ${EVMJIT_INCLUDE_DIR}/evmjit/DataTypes.h
     Endianness.cpp		Endianness.h
     ExecStats.cpp		ExecStats.h
     ExecutionEngine.cpp	ExecutionEngine.h
@@ -15,6 +16,7 @@ set(SOURCES
     GasMeter.cpp		GasMeter.h
     Instruction.cpp		Instruction.h
     interface.cpp		interface.h
+    JIT.cpp             ${EVMJIT_INCLUDE_DIR}/evmjit/JIT.h
     Memory.cpp			Memory.h
     Optimizer.cpp		Optimizer.h
     Runtime.cpp			Runtime.h
@@ -79,6 +81,7 @@ set_target_properties(${TARGET_NAME} PROPERTIES
 						VERSION ${EVMJIT_VERSION} SOVERSION ${EVMJIT_SOVERSION}
 						FOLDER "libs")
 
+include_directories(${EVMJIT_INCLUDE_DIR})
 include_directories(${LLVM_INCLUDE_DIRS})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/gen)
 

libevmjit/Common.h

@@ -46,16 +46,6 @@ enum class ReturnCode
 	LinkerWorkaround = -299,
 };
 
-/// Representation of 256-bit value binary compatible with LLVM i256
-struct i256
-{
-	uint64_t a = 0;
-	uint64_t b = 0;
-	uint64_t c = 0;
-	uint64_t d = 0;
-};
-static_assert(sizeof(i256) == 32, "Wrong i265 size");
-
 #define UNTESTED assert(false)
 
 }

libevmjit/ExecutionEngine.cpp

@@ -19,6 +19,7 @@
 #include <llvm/Support/ManagedStatic.h>
 #include "preprocessor/llvm_includes_end.h"
 
+#include "evmjit/JIT.h"
 #include "Runtime.h"
 #include "Compiler.h"
 #include "Optimizer.h"
@@ -33,6 +34,7 @@ namespace eth
 {
 namespace jit
 {
+using evmjit::JIT;
 
 namespace
 {
@@ -119,8 +121,6 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 	// TODO: Do not pseudo-init the cache every time
 	auto objectCache = (g_cache != CacheMode::off && g_cache != CacheMode::clear) ? Cache::getObjectCache(g_cache, listener.get()) : nullptr;
 
-	static std::unordered_map<std::string, uint64_t> funcCache;
-
 	static std::unique_ptr<llvm::ExecutionEngine> ee;
 	if (!ee)
 	{
@@ -147,8 +147,9 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 		module.release();  // Successfully created llvm::ExecutionEngine takes ownership of the module
 		ee->setObjectCache(objectCache);
 
-		if (preloadCache)
+		// FIXME: Disabled during API changes
-			Cache::preload(*ee, funcCache);
+		//if (preloadCache)
+		//	Cache::preload(*ee, funcCache);
 	}
 
 	static StatsCollector statsCollector;
@@ -156,11 +157,8 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 	auto mainFuncName = codeHash(_data->codeHash);
 	m_runtime.init(_data, _env);
 
-	EntryFuncPtr entryFuncPtr = nullptr;
+	// TODO: Remove cast
-	auto it = funcCache.find(mainFuncName);
+	auto entryFuncPtr = (EntryFuncPtr) JIT::getCode(_data->codeHash);
-	if (it != funcCache.end())
-		entryFuncPtr = (EntryFuncPtr) it->second;
-
 	if (!entryFuncPtr)
 	{
 		auto module = objectCache ? Cache::getObject(mainFuncName) : nullptr;
@@ -183,12 +181,10 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 		module.release();
 		listener->stateChanged(ExecState::CodeGen);
 		entryFuncPtr = (EntryFuncPtr)ee->getFunctionAddress(mainFuncName);
-	}
 		if (!CHECK(entryFuncPtr))
 			return ReturnCode::LLVMLinkError;
-
+		JIT::mapCode(_data->codeHash, (void*)entryFuncPtr); // FIXME: Remove cast
-	if (it == funcCache.end())
+	}
-		funcCache[mainFuncName] = (uint64_t) entryFuncPtr;
 
 	listener->stateChanged(ExecState::Execution);
 	auto returnCode = entryFuncPtr(&m_runtime);

libevmjit/JIT.cpp

@@ -0,0 +1,46 @@
+#include "evmjit/JIT.h"
+
+#include <unordered_map>
+
+namespace dev
+{
+namespace evmjit
+{
+namespace
+{
+
+class JITImpl: JIT
+{
+public:
+	std::unordered_map<h256, void*> codeMap;
+
+	static JITImpl& instance()
+	{
+		static JITImpl s_instance;
+		return s_instance;
+	}
+};
+
+} // anonymous namespace
+
+bool JIT::isCodeReady(h256 _codeHash)
+{
+	return JITImpl::instance().codeMap.count(_codeHash) != 0;
+}
+
+void* JIT::getCode(h256 _codeHash)
+{
+	auto& codeMap = JITImpl::instance().codeMap;
+	auto it = codeMap.find(_codeHash);
+	if (it != codeMap.end())
+		return it->second;
+	return nullptr;
+}
+
+void JIT::mapCode(h256 _codeHash, void* _funcAddr)
+{
+	JITImpl::instance().codeMap.insert(std::make_pair(_codeHash, _funcAddr));
+}
+
+}
+}

libevmjit/RuntimeData.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "evmjit/DataTypes.h"
 #include "Common.h"
 
 namespace dev
@@ -8,6 +9,8 @@ namespace eth
 {
 namespace jit
 {
+using evmjit::i256;
+using evmjit::h256;
 
 struct RuntimeData
 {
@@ -49,7 +52,7 @@ struct RuntimeData
 	int64_t 	timestamp = 0;
 	byte const* code = nullptr;
 	uint64_t 	codeSize = 0;
-	i256		codeHash;
+	h256		codeHash;
 };
 
 /// VM Environment (ExtVM) opaque type