cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove memory logging.

Browse Source
This commit is contained in:
chriseth 2019-05-23 11:35:12 +02:00
parent 91312e657b
commit 3ef03258ec
2 changed files with 26 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
test/tools/yulInterpreter/EVMInstructionInterpreter.cpp
View File

@ -186,7 +186,7 @@ u256 EVMInstructionInterpreter::eval(
// --------------- blockchain stuff --------------- // --------------- blockchain stuff ---------------
case Instruction::KECCAK256: case Instruction::KECCAK256:
{ {
if (!logMemoryRead(arg[0], arg[1])) if (!accessMemory(arg[0], arg[1]))
return u256("0x1234cafe1234cafe1234cafe") + arg[0]; return u256("0x1234cafe1234cafe1234cafe") + arg[0];
uint64_t offset = uint64_t(arg[0] & uint64_t(-1)); uint64_t offset = uint64_t(arg[0] & uint64_t(-1));
uint64_t size = uint64_t(arg[1] & uint64_t(-1)); uint64_t size = uint64_t(arg[1] & uint64_t(-1));
@ -207,7 +207,7 @@ u256 EVMInstructionInterpreter::eval(
case Instruction::CALLDATASIZE: case Instruction::CALLDATASIZE:
return m_state.calldata.size(); return m_state.calldata.size();
case Instruction::CALLDATACOPY: case Instruction::CALLDATACOPY:
if (logMemoryWrite(arg[0], arg[2])) if (accessMemory(arg[0], arg[2]))
copyZeroExtended( copyZeroExtended(
m_state.memory, m_state.calldata, m_state.memory, m_state.calldata,
size_t(arg[0]), size_t(arg[1]), size_t(arg[2]) size_t(arg[0]), size_t(arg[1]), size_t(arg[2])
@ -216,7 +216,7 @@ u256 EVMInstructionInterpreter::eval(
case Instruction::CODESIZE: case Instruction::CODESIZE:
return m_state.code.size(); return m_state.code.size();
case Instruction::CODECOPY: case Instruction::CODECOPY:
if (logMemoryWrite(arg[0], arg[2])) if (accessMemory(arg[0], arg[2]))
copyZeroExtended( copyZeroExtended(
m_state.memory, m_state.code, m_state.memory, m_state.code,
size_t(arg[0]), size_t(arg[1]), size_t(arg[2]) size_t(arg[0]), size_t(arg[1]), size_t(arg[2])
@ -232,7 +232,7 @@ u256 EVMInstructionInterpreter::eval(
return u256(keccak256(h256(arg[0] + 1))); return u256(keccak256(h256(arg[0] + 1)));
case Instruction::EXTCODECOPY: case Instruction::EXTCODECOPY:
logTrace(_instruction, arg); logTrace(_instruction, arg);
if (logMemoryWrite(arg[1], arg[3])) if (accessMemory(arg[1], arg[3]))
// TODO this way extcodecopy and codecopy do the same thing. // TODO this way extcodecopy and codecopy do the same thing.
copyZeroExtended( copyZeroExtended(
m_state.memory, m_state.code, m_state.memory, m_state.code,
@ -244,7 +244,7 @@ u256 EVMInstructionInterpreter::eval(
return m_state.returndata.size(); return m_state.returndata.size();
case Instruction::RETURNDATACOPY: case Instruction::RETURNDATACOPY:
logTrace(_instruction, arg); logTrace(_instruction, arg);
if (logMemoryWrite(arg[0], arg[2])) if (accessMemory(arg[0], arg[2]))
copyZeroExtended( copyZeroExtended(
m_state.memory, m_state.returndata, m_state.memory, m_state.returndata,
size_t(arg[0]), size_t(arg[1]), size_t(arg[2]) size_t(arg[0]), size_t(arg[1]), size_t(arg[2])
@ -267,16 +267,16 @@ u256 EVMInstructionInterpreter::eval(
return m_state.gaslimit; return m_state.gaslimit;
// --------------- memory / storage / logs --------------- // --------------- memory / storage / logs ---------------
case Instruction::MLOAD: case Instruction::MLOAD:
if (logMemoryRead(arg[0], 0x20)) if (accessMemory(arg[0], 0x20))
return u256(*reinterpret_cast<h256 const*>(m_state.memory.data() + size_t(arg[0]))); return u256(*reinterpret_cast<h256 const*>(m_state.memory.data() + size_t(arg[0])));
else else
return 0x1234 + arg[0]; return 0x1234 + arg[0];
case Instruction::MSTORE: case Instruction::MSTORE:
if (logMemoryWrite(arg[0], 0x20, h256(arg[1]).asBytes())) if (accessMemory(arg[0], 0x20))
*reinterpret_cast<h256*>(m_state.memory.data() + size_t(arg[0])) = h256(arg[1]); *reinterpret_cast<h256*>(m_state.memory.data() + size_t(arg[0])) = h256(arg[1]);
return 0; return 0;
case Instruction::MSTORE8: case Instruction::MSTORE8:
if (logMemoryWrite(arg[0], 1, bytes{1, uint8_t(arg[1] & 0xff)})) if (accessMemory(arg[0], 1))
m_state.memory[size_t(arg[0])] = uint8_t(arg[1] & 0xff); m_state.memory[size_t(arg[0])] = uint8_t(arg[1] & 0xff);
return 0; return 0;
case Instruction::SLOAD: case Instruction::SLOAD:
@ -296,57 +296,57 @@ u256 EVMInstructionInterpreter::eval(
logTrace(_instruction); logTrace(_instruction);
return 0x99; return 0x99;
case Instruction::LOG0: case Instruction::LOG0:
logMemoryRead(arg[0], arg[1]); accessMemory(arg[0], arg[1]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0; return 0;
case Instruction::LOG1: case Instruction::LOG1:
logMemoryRead(arg[0], arg[1]); accessMemory(arg[0], arg[1]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0; return 0;
case Instruction::LOG2: case Instruction::LOG2:
logMemoryRead(arg[0], arg[1]); accessMemory(arg[0], arg[1]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0; return 0;
case Instruction::LOG3: case Instruction::LOG3:
logMemoryRead(arg[0], arg[1]); accessMemory(arg[0], arg[1]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0; return 0;
case Instruction::LOG4: case Instruction::LOG4:
logMemoryRead(arg[0], arg[1]); accessMemory(arg[0], arg[1]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0; return 0;
// --------------- calls --------------- // --------------- calls ---------------
case Instruction::CREATE: case Instruction::CREATE:
logMemoryRead(arg[1], arg[2]); accessMemory(arg[1], arg[2]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0xcccccc + arg[1]; return 0xcccccc + arg[1];
case Instruction::CREATE2: case Instruction::CREATE2:
logMemoryRead(arg[2], arg[3]); accessMemory(arg[2], arg[3]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0xdddddd + arg[1]; return 0xdddddd + arg[1];
case Instruction::CALL: case Instruction::CALL:
case Instruction::CALLCODE: case Instruction::CALLCODE:
// TODO assign returndata // TODO assign returndata
logMemoryRead(arg[3], arg[4]); accessMemory(arg[3], arg[4]);
logMemoryWrite(arg[5], arg[6]); accessMemory(arg[5], arg[6]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return arg[0] & 1; return arg[0] & 1;
case Instruction::DELEGATECALL: case Instruction::DELEGATECALL:
case Instruction::STATICCALL: case Instruction::STATICCALL:
logMemoryRead(arg[2], arg[3]); accessMemory(arg[2], arg[3]);
logMemoryWrite(arg[4], arg[5]); accessMemory(arg[4], arg[5]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
return 0; return 0;
case Instruction::RETURN: case Instruction::RETURN:
{ {
bytes data; bytes data;
if (logMemoryRead(arg[0], arg[1])) if (accessMemory(arg[0], arg[1]))
data = bytesConstRef(m_state.memory.data() + size_t(arg[0]), size_t(arg[1])).toBytes(); data = bytesConstRef(m_state.memory.data() + size_t(arg[0]), size_t(arg[1])).toBytes();
logTrace(_instruction, arg, data); logTrace(_instruction, arg, data);
throw ExplicitlyTerminated(); throw ExplicitlyTerminated();
} }
case Instruction::REVERT: case Instruction::REVERT:
logMemoryRead(arg[0], arg[1]); accessMemory(arg[0], arg[1]);
logTrace(_instruction, arg); logTrace(_instruction, arg);
throw ExplicitlyTerminated(); throw ExplicitlyTerminated();
case Instruction::INVALID: case Instruction::INVALID:
@ -456,7 +456,7 @@ u256 EVMInstructionInterpreter::evalBuiltin(BuiltinFunctionForEVM const& _fun, c
else if (_fun.name == "datacopy"_yulstring) else if (_fun.name == "datacopy"_yulstring)
{ {
// This is identical to codecopy. // This is identical to codecopy.
if (logMemoryWrite(_arguments.at(0), _arguments.at(2))) if (accessMemory(_arguments.at(0), _arguments.at(2)))
copyZeroExtended( copyZeroExtended(
m_state.memory, m_state.memory,
m_state.code, m_state.code,
@ -470,20 +470,9 @@ u256 EVMInstructionInterpreter::evalBuiltin(BuiltinFunctionForEVM const& _fun, c
return 0; return 0;
} }
bool EVMInstructionInterpreter::logMemoryRead(u256 const& _offset, u256 const& _size)
{
return logMemory(false, _offset, _size);
}
bool EVMInstructionInterpreter::logMemoryWrite(u256 const& _offset, u256 const& _size, bytes const& _data) bool EVMInstructionInterpreter::accessMemory(u256 const& _offset, u256 const& _size)
{ {
return logMemory(true, _offset, _size, _data);
}
bool EVMInstructionInterpreter::logMemory(bool _write, u256 const& _offset, u256 const& _size, bytes const& _data)
{
logTrace(_write ? "MSTORE_AT_SIZE" : "MLOAD_FROM_SIZE", {_offset, _size}, _data);
if (((_offset + _size) >= _offset) && ((_offset + _size + 0x1f) >= (_offset + _size))) if (((_offset + _size) >= _offset) && ((_offset + _size + 0x1f) >= (_offset + _size)))
{ {
u256 newSize = (_offset + _size + 0x1f) & ~u256(0x1f); u256 newSize = (_offset + _size + 0x1f) & ~u256(0x1f);

11
test/tools/yulInterpreter/EVMInstructionInterpreter.h
View File

@ -75,14 +75,9 @@ public:
dev::u256 evalBuiltin(BuiltinFunctionForEVM const& _fun, std::vector<dev::u256> const& _arguments); dev::u256 evalBuiltin(BuiltinFunctionForEVM const& _fun, std::vector<dev::u256> const& _arguments);
private: private:
/// Record a memory read in the trace. Also updates m_state.msize /// Resizes the memory to accommodate the memory access.
/// @returns true if m_state.memory can be used at that offset. /// @returns false if memory would have to be expanded beyond m_state.maxMemSize.
bool logMemoryRead(dev::u256 const& _offset, dev::u256 const& _size = 32); bool accessMemory(dev::u256 const& _offset, dev::u256 const& _size = 32);
/// Record a memory write in the trace. Also updates m_state.msize
/// @returns true if m_state.memory can be used at that offset.
bool logMemoryWrite(dev::u256 const& _offset, dev::u256 const& _size = 32, dev::bytes const& _data = {});
bool logMemory(bool _write, dev::u256 const& _offset, dev::u256 const& _size = 32, dev::bytes const& _data = {});
void logTrace(dev::eth::Instruction _instruction, std::vector<dev::u256> const& _arguments = {}, dev::bytes const& _data = {}); void logTrace(dev::eth::Instruction _instruction, std::vector<dev::u256> const& _arguments = {}, dev::bytes const& _data = {});
/// Appends a log to the trace representing an instruction or similar operation by string, /// Appends a log to the trace representing an instruction or similar operation by string,