Merge remote-tracking branch 'upstream/develop' into evmjit-develop

Conflicts:
	evmjit/libevmjit-cpp/JitVM.cpp
	evmjit/libevmjit-cpp/JitVM.h

libevmjit-cpp/Env.cpp

@@ -53,7 +53,7 @@ extern "C"
 		if (_env->balance(_env->myAddress) >= endowment && _env->depth < 1024)
 		{
 			u256 gas = *io_gas;
-			h256 address(_env->create(endowment, gas, {_initBeg, _initSize}, {}), h256::AlignRight);
+			h256 address(_env->create(endowment, gas, {_initBeg, (size_t)_initSize}, {}), h256::AlignRight);
 			*io_gas = static_cast<int64_t>(gas);
 			*o_address = address;
 		}
@@ -68,8 +68,8 @@ extern "C"
 		params.senderAddress = _env->myAddress;
 		params.receiveAddress = right160(*_receiveAddress);
 		params.codeAddress = right160(*_codeAddress);
-		params.data = {_inBeg, _inSize};
+		params.data = {_inBeg, (size_t)_inSize};
-		params.out = {_outBeg, _outSize};
+		params.out = {_outBeg, (size_t)_outSize};
 		params.onOp = {};
 		const auto isCall = params.receiveAddress == params.codeAddress; // OPT: The same address pointer can be used if not CODECALL
 
@@ -101,7 +101,7 @@ extern "C"
 
 	EXPORT void env_sha3(byte* _begin, uint64_t _size, h256* o_hash)
 	{
-		auto hash = sha3({_begin, _size});
+		auto hash = sha3({_begin, (size_t)_size});
 		*o_hash = hash;
 	}
 
@@ -129,7 +129,7 @@ extern "C"
 		if (_topic4)
 			topics.push_back(*_topic4);
 
-		_env->log(std::move(topics), {_beg, _size});
+		_env->log(std::move(topics), {_beg, (size_t)_size});
 	}
 }
 

libevmjit-cpp/JitVM.cpp

@@ -17,25 +17,23 @@ namespace eth
 
 extern "C" void env_sload(); // fake declaration for linker symbol stripping workaround, see a call below
 
-bytesConstRef JitVM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _step)
+bytesConstRef JitVM::execImpl(u256& io_gas, ExtVMFace& _ext, OnOpFunc const& _onOp)
 {
 	auto rejected = false;
 	// TODO: Rejecting transactions with gas limit > 2^63 can be used by attacker to take JIT out of scope
-	rejected |= m_gas > std::numeric_limits<decltype(m_data.gas)>::max(); // Do not accept requests with gas > 2^63 (int64 max)
+	rejected |= io_gas > std::numeric_limits<decltype(m_data.gas)>::max(); // Do not accept requests with gas > 2^63 (int64 max)
 	rejected |= _ext.gasPrice > std::numeric_limits<decltype(m_data.gasPrice)>::max();
 	rejected |= _ext.currentBlock.number > std::numeric_limits<decltype(m_data.number)>::max();
 	rejected |= _ext.currentBlock.timestamp > std::numeric_limits<decltype(m_data.timestamp)>::max();
 
 	if (rejected)
 	{
-		cwarn << "Execution rejected by EVM JIT (gas limit: " << m_gas << "), executing with interpreter";
+		cwarn << "Execution rejected by EVM JIT (gas limit: " << io_gas << "), executing with interpreter";
-		m_fallbackVM = VMFactory::create(VMKind::Interpreter, m_gas);
+		m_fallbackVM = VMFactory::create(VMKind::Interpreter);
-		auto&& output = m_fallbackVM->go(_ext, _onOp, _step);
+		return m_fallbackVM->execImpl(io_gas, _ext, _onOp);
-		m_gas = m_fallbackVM->gas(); // copy remaining gas, Executive expects it
-		return output;
 	}
 
-	m_data.gas 			= static_cast<decltype(m_data.gas)>(m_gas);
+	m_data.gas 			= static_cast<decltype(m_data.gas)>(io_gas);
 	m_data.gasPrice		= static_cast<decltype(m_data.gasPrice)>(_ext.gasPrice);
 	m_data.callData 	= _ext.data.data();
 	m_data.callDataSize = _ext.data.size();
@@ -50,7 +48,7 @@ bytesConstRef JitVM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _step)
 	m_data.timestamp 	= static_cast<decltype(m_data.timestamp)>(_ext.currentBlock.timestamp);
 	m_data.code     	= _ext.code.data();
 	m_data.codeSize 	= _ext.code.size();
-	m_data.codeHash		= eth2jit(sha3(_ext.code));
+	m_data.codeHash		= eth2jit(_ext.codeHash);
 
 	m_context.init(m_data, reinterpret_cast<evmjit::Env*>(&_ext));
 	auto exitCode = evmjit::JIT::exec(m_context);
@@ -75,7 +73,7 @@ bytesConstRef JitVM::go(ExtVMFace& _ext, OnOpFunc const& _onOp, uint64_t _step)
 		break;
 	}
 
-	m_gas = m_data.gas; // TODO: Remove m_gas field
+	io_gas = m_data.gas;
 	return {std::get<0>(m_context.returnData), std::get<1>(m_context.returnData)};
 }
 

libevmjit-cpp/JitVM.h

@@ -10,16 +10,10 @@ namespace eth
 
 class JitVM: public VMFace
 {
-	virtual bytesConstRef go(ExtVMFace& _ext, OnOpFunc const& _onOp = {}, uint64_t _steps = (uint64_t)-1) override final;
+public:
-
+	virtual bytesConstRef execImpl(u256& io_gas, ExtVMFace& _ext, OnOpFunc const& _onOp) override final;
-	virtual u256 gas() const noexcept { return m_gas; }
-	virtual void reset(u256 const& _gas = 0) noexcept { m_gas = _gas; }
 
 private:
-	friend class VMFactory;
-	explicit JitVM(u256 _gas = 0): m_gas(_gas) {}
-
-	u256 m_gas;
 	evmjit::RuntimeData m_data;
 	evmjit::ExecutionContext m_context;
 	std::unique_ptr<VMFace> m_fallbackVM; ///< VM used in case of input data rejected by JIT