Merge pull request #13283 from ethereum/yulDebugger

ekpyron · web-flow · commit bbaf8a4eb4e4 · 2022-11-01T14:04:56.000+01:00
Yul Debugger
diff --git a/libevmasm/Instruction.h b/libevmasm/Instruction.h
@@ -188,6 +188,21 @@ enum class Instruction: uint8_t
 	SELFDESTRUCT = 0xff	///< halt execution and register account for later deletion
 };
 
+/// @returns true if the instruction is of the CALL opcode family
+constexpr bool isCallInstruction(Instruction _inst) noexcept
+{
+	switch (_inst)
+	{
+		case Instruction::CALL:
+		case Instruction::CALLCODE:
+		case Instruction::DELEGATECALL:
+		case Instruction::STATICCALL:
+			return true;
+		default:
+			return false;
+	}
+}
+
 /// @returns true if the instruction is a PUSH
 inline bool isPushInstruction(Instruction _inst)
 {
diff --git a/test/libyul/EwasmTranslationTest.cpp b/test/libyul/EwasmTranslationTest.cpp
@@ -112,6 +112,7 @@ string EwasmTranslationTest::interpret()
 			state,
 			WasmDialect{},
 			*m_object->code,
+			/*disableExternalCalls=*/true,
 			/*disableMemoryTracing=*/false
 		);
 	}
diff --git a/test/libyul/YulInterpreterTest.cpp b/test/libyul/YulInterpreterTest.cpp
@@ -51,6 +51,7 @@ YulInterpreterTest::YulInterpreterTest(string const& _filename):
 {
 	m_source = m_reader.source();
 	m_expectation = m_reader.simpleExpectations();
+	m_simulateExternalCallsToSelf = m_reader.boolSetting("simulateExternalCall", false);
 }
 
 TestCase::TestResult YulInterpreterTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted)
@@ -98,7 +99,8 @@ string YulInterpreterTest::interpret()
 			state,
 			EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion{}),
 			*m_ast,
-			/*disableMemoryTracing=*/false
+			/*disableExternalCalls=*/ !m_simulateExternalCallsToSelf,
+			/*disableMemoryTracing=*/ false
 		);
 	}
 	catch (InterpreterTerminatedGeneric const&)
diff --git a/test/libyul/YulInterpreterTest.h b/test/libyul/YulInterpreterTest.h
@@ -47,6 +47,7 @@ class YulInterpreterTest: public solidity::frontend::test::EVMVersionRestrictedT
 
 	std::shared_ptr<Block> m_ast;
 	std::shared_ptr<AsmAnalysisInfo> m_analysisInfo;
+	bool m_simulateExternalCallsToSelf = false;
 };
 
 }
diff --git a/test/libyul/yulInterpreterTests/external_call_to_self.yul b/test/libyul/yulInterpreterTests/external_call_to_self.yul
@@ -0,0 +1,22 @@
+{
+	mstore(0x40, 0x42)
+
+	if iszero(calldatasize()) {
+		let x := call(gas(), address(), 0, 0x40, 0x20, 0x100, 0x20)
+		sstore(0x64, calldataload(0))
+		sstore(0x100, x)
+		return(0x0, 0)
+	}
+	return(0x40, 0x20)
+}
+// ====
+// simulateExternalCall: true
+// ----
+// Trace:
+//   CALL(153, 0x11111111, 0, 64, 32, 256, 32)
+//   RETURN(0, 0)
+// Memory dump:
+//     40: 0000000000000000000000000000000000000000000000000000000000000042
+//    100: 0000000000000000000000000000000000000000000000000000000000000042
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000100: 0000000000000000000000000000000000000000000000000000000000000001
diff --git a/test/libyul/yulInterpreterTests/external_call_unexecuted.yul b/test/libyul/yulInterpreterTests/external_call_unexecuted.yul
@@ -1,6 +1,6 @@
 {
 	let x := call(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)
-	sstore(100, x)
+	sstore(0x64, x)
 }
 // ----
 // Trace:
diff --git a/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul b/test/libyul/yulInterpreterTests/external_callcode_unexecuted.yul
@@ -0,0 +1,10 @@
+{
+	let x := callcode(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)
+	sstore(100, x)
+}
+// ----
+// Trace:
+//   CALLCODE(153, 69, 5, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
diff --git a/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul b/test/libyul/yulInterpreterTests/external_delegatecall_unexecuted.yul
@@ -0,0 +1,10 @@
+{
+	let x := delegatecall(gas(), 0x45, 0, 0x20, 0x30, 0x20)
+	sstore(100, x)
+}
+// ----
+// Trace:
+//   DELEGATECALL(153, 69, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
diff --git a/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul b/test/libyul/yulInterpreterTests/external_staticcall_unexecuted.yul
@@ -0,0 +1,12 @@
+{
+	let x := staticcall(gas(), 0x45, 0, 0x20, 0x30, 0x20)
+	sstore(0x64, x)
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// Trace:
+//   STATICCALL(153, 69, 0, 32, 48, 32)
+// Memory dump:
+// Storage dump:
+//   0000000000000000000000000000000000000000000000000000000000000064: 0000000000000000000000000000000000000000000000000000000000000001
diff --git a/test/tools/ossfuzz/yulFuzzerCommon.cpp b/test/tools/ossfuzz/yulFuzzerCommon.cpp
@@ -53,7 +53,7 @@ yulFuzzerUtil::TerminationReason yulFuzzerUtil::interpret(
 	TerminationReason reason = TerminationReason::None;
 	try
 	{
-		Interpreter::run(state, _dialect, *_ast, _disableMemoryTracing);
+		Interpreter::run(state, _dialect, *_ast, true, _disableMemoryTracing);
 	}
 	catch (StepLimitReached const&)
 	{
diff --git a/test/tools/yulInterpreter/CMakeLists.txt b/test/tools/yulInterpreter/CMakeLists.txt
@@ -5,6 +5,8 @@ set(sources
 	EwasmBuiltinInterpreter.cpp
 	Interpreter.h
 	Interpreter.cpp
+	Inspector.h
+	Inspector.cpp
 )
 
 add_library(yulInterpreter ${sources})
diff --git a/test/tools/yulInterpreter/EVMInstructionInterpreter.cpp b/test/tools/yulInterpreter/EVMInstructionInterpreter.cpp
@@ -70,6 +70,10 @@ u256 readZeroExtended(bytes const& _data, u256 const& _offset)
 	}
 }
 
+}
+
+namespace solidity::yul::test
+{
 /// Copy @a _size bytes of @a _source at offset @a _sourceOffset to
 /// @a _target at offset @a _targetOffset. Behaves as if @a _source would
 /// continue with an infinite sequence of zero bytes beyond its end.
@@ -185,7 +189,7 @@ u256 EVMInstructionInterpreter::eval(
 			return u256("0x1234cafe1234cafe1234cafe") + arg[0];
 		uint64_t offset = uint64_t(arg[0] & uint64_t(-1));
 		uint64_t size = uint64_t(arg[1] & uint64_t(-1));
-		return u256(keccak256(readMemory(offset, size)));
+		return u256(keccak256(m_state.readMemory(offset, size)));
 	}
 	case Instruction::ADDRESS:
 		return h256(m_state.address, h256::AlignRight);
@@ -322,24 +326,34 @@ u256 EVMInstructionInterpreter::eval(
 		return (0xdddddd + arg[1]) & u256("0xffffffffffffffffffffffffffffffffffffffff");
 	case Instruction::CALL:
 	case Instruction::CALLCODE:
-		// TODO assign returndata
 		accessMemory(arg[3], arg[4]);
 		accessMemory(arg[5], arg[6]);
 		logTrace(_instruction, arg);
-		return arg[0] & 1;
+		// Randomly fail based on the called address if it isn't a call to self.
+		// Used for fuzzing.
+		return (
+			(arg[0] > 0) &&
+			(arg[1] == util::h160::Arith(m_state.address) || (arg[1] & 1))
+		) ? 1 : 0;
 	case Instruction::DELEGATECALL:
 	case Instruction::STATICCALL:
 		accessMemory(arg[2], arg[3]);
 		accessMemory(arg[4], arg[5]);
 		logTrace(_instruction, arg);
-		return 0;
+
+		// Randomly fail based on the called address if it isn't a call to self.
+		// Used for fuzzing.
+		return (
+			(arg[0] > 0) &&
+			(arg[1] == util::h160::Arith(m_state.address) || (arg[1] & 1))
+		) ? 1 : 0;
 	case Instruction::RETURN:
 	{
-		bytes data;
+		m_state.returndata = {};
 		if (accessMemory(arg[0], arg[1]))
-			data = readMemory(arg[0], arg[1]);
-		logTrace(_instruction, arg, data);
-		BOOST_THROW_EXCEPTION(ExplicitlyTerminated());
+			m_state.returndata = m_state.readMemory(arg[0], arg[1]);
+		logTrace(_instruction, arg, m_state.returndata);
+		BOOST_THROW_EXCEPTION(ExplicitlyTerminatedWithReturn());
 	}
 	case Instruction::REVERT:
 		accessMemory(arg[0], arg[1]);
@@ -475,6 +489,8 @@ u256 EVMInstructionInterpreter::evalBuiltin(
 			);
 		return 0;
 	}
+	else if (fun == "memoryguard")
+		return _evaluatedArguments.at(0);
 	else
 		yulAssert(false, "Unknown builtin: " + fun);
 	return 0;
@@ -497,18 +513,9 @@ bool EVMInstructionInterpreter::accessMemory(u256 const& _offset, u256 const& _s
 	return false;
 }
 
-bytes EVMInstructionInterpreter::readMemory(u256 const& _offset, u256 const& _size)
-{
-	yulAssert(_size <= 0xffff, "Too large read.");
-	bytes data(size_t(_size), uint8_t(0));
-	for (size_t i = 0; i < data.size(); ++i)
-		data[i] = m_state.memory[_offset + i];
-	return data;
-}
-
 u256 EVMInstructionInterpreter::readMemoryWord(u256 const& _offset)
 {
-	return u256(h256(readMemory(_offset, 32)));
+	return u256(h256(m_state.readMemory(_offset, 32)));
 }
 
 void EVMInstructionInterpreter::writeMemoryWord(u256 const& _offset, u256 const& _value)
diff --git a/test/tools/yulInterpreter/EVMInstructionInterpreter.h b/test/tools/yulInterpreter/EVMInstructionInterpreter.h
@@ -42,6 +42,14 @@ struct BuiltinFunctionForEVM;
 namespace solidity::yul::test
 {
 
+/// Copy @a _size bytes of @a _source at offset @a _sourceOffset to
+/// @a _target at offset @a _targetOffset. Behaves as if @a _source would
+/// continue with an infinite sequence of zero bytes beyond its end.
+void copyZeroExtended(
+	std::map<u256, uint8_t>& _target, bytes const& _source,
+	size_t _targetOffset, size_t _sourceOffset, size_t _size
+);
+
 struct InterpreterState;
 
 /**
diff --git a/test/tools/yulInterpreter/Inspector.cpp b/test/tools/yulInterpreter/Inspector.cpp
diff --git a/test/tools/yulInterpreter/Inspector.h b/test/tools/yulInterpreter/Inspector.h
diff --git a/test/tools/yulInterpreter/Interpreter.cpp b/test/tools/yulInterpreter/Interpreter.cpp
diff --git a/test/tools/yulInterpreter/Interpreter.h b/test/tools/yulInterpreter/Interpreter.h
diff --git a/test/tools/yulrun.cpp b/test/tools/yulrun.cpp

Original file line number	Diff line number	Diff line change
`@@ -112,6 +112,7 @@ string EwasmTranslationTest::interpret()`
`112`	`112`	`state,`
`113`	`113`	`WasmDialect{},`
`114`	`114`	`*m_object->code,`
	`115`	`+ /disableExternalCalls=/true,`
`115`	`116`	`/disableMemoryTracing=/false`
`116`	`117`	`);`
`117`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,7 @@ YulInterpreterTest::YulInterpreterTest(string const& _filename):`
`51`	`51`	`{`
`52`	`52`	`m_source = m_reader.source();`
`53`	`53`	`m_expectation = m_reader.simpleExpectations();`
	`54`	`+ m_simulateExternalCallsToSelf = m_reader.boolSetting("simulateExternalCall", false);`
`54`	`55`	`}`
`55`	`56`
`56`	`57`	`TestCase::TestResult YulInterpreterTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted)`
`@@ -98,7 +99,8 @@ string YulInterpreterTest::interpret()`
`98`	`99`	`state,`
`99`	`100`	`EVMDialect::strictAssemblyForEVMObjects(langutil::EVMVersion{}),`
`100`	`101`	`*m_ast,`
`101`		`- /disableMemoryTracing=/false`
	`102`	`+ /disableExternalCalls=/ !m_simulateExternalCallsToSelf,`
	`103`	`+ /disableMemoryTracing=/ false`
`102`	`104`	`);`
`103`	`105`	`}`
`104`	`106`	`catch (InterpreterTerminatedGeneric const&)`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@ class YulInterpreterTest: public solidity::frontend::test::EVMVersionRestrictedT`
`47`	`47`
`48`	`48`	`std::shared_ptr<Block> m_ast;`
`49`	`49`	`std::shared_ptr<AsmAnalysisInfo> m_analysisInfo;`
	`50`	`+ bool m_simulateExternalCallsToSelf = false;`
`50`	`51`	`};`
`51`	`52`
`52`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`let x := call(gas(), 0x45, 0x5, 0, 0x20, 0x30, 0x20)`
`3`		`- sstore(100, x)`
	`3`	`+ sstore(0x64, x)`
`4`	`4`	`}`
`5`	`5`	`// ----`
`6`	`6`	`// Trace:`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ yulFuzzerUtil::TerminationReason yulFuzzerUtil::interpret(`
`53`	`53`	`TerminationReason reason = TerminationReason::None;`
`54`	`54`	`try`
`55`	`55`	`{`
`56`		`- Interpreter::run(state, _dialect, *_ast, _disableMemoryTracing);`
	`56`	`+ Interpreter::run(state, _dialect, *_ast, true, _disableMemoryTracing);`
`57`	`57`	`}`
`58`	`58`	`catch (StepLimitReached const&)`
`59`	`59`	`{`