From 96a50b3a23cb4cd85c88fb4ad41e33ff8c6dbba6 Mon Sep 17 00:00:00 2001 From: Christian Date: Fri, 27 Feb 2015 22:52:02 +0100 Subject: [PATCH] Array copy storage to storage. --- libsolidity/ArrayUtils.cpp | 72 +++++++++++++++++----------- libsolidity/ArrayUtils.h | 8 +++- test/SolidityEndToEndTest.cpp | 88 +++++++++++++++++++++++++++++++++++ 3 files changed, 141 insertions(+), 27 deletions(-) diff --git a/libsolidity/ArrayUtils.cpp b/libsolidity/ArrayUtils.cpp index 07949c79e..43cc6fd49 100644 --- a/libsolidity/ArrayUtils.cpp +++ b/libsolidity/ArrayUtils.cpp @@ -37,13 +37,17 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons // stack layout: [source_ref] target_ref (top) // need to leave target_ref on the stack at the end solAssert(_targetType.getLocation() == ArrayType::Location::Storage, ""); - solAssert(_targetType.isByteArray(), "Non byte arrays not yet implemented here."); - solAssert(_sourceType.isByteArray(), "Non byte arrays not yet implemented here."); + + IntegerType uint256(256); + Type const* targetBaseType = _targetType.isByteArray() ? &uint256 : &(*_targetType.getBaseType()); + Type const* sourceBaseType = _sourceType.isByteArray() ? &uint256 : &(*_sourceType.getBaseType()); switch (_sourceType.getLocation()) { case ArrayType::Location::CallData: { + solAssert(_targetType.isByteArray(), "Non byte arrays not yet implemented here."); + solAssert(_sourceType.isByteArray(), "Non byte arrays not yet implemented here."); // This also assumes that after "length" we only have zeros, i.e. it cannot be used to // slice a byte array from calldata. @@ -97,30 +101,37 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons { // this copies source to target and also clears target if it was larger + solAssert(sourceBaseType->getStorageSize() == targetBaseType->getStorageSize(), + "Copying with different storage sizes not yet implemented."); // stack: source_ref target_ref // store target_ref m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2; + // stack: target_ref source_ref target_ref // fetch lengthes - m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP2 - << eth::Instruction::DUP1 << eth::Instruction::SLOAD; - // stack: target_ref target_len_bytes target_ref source_ref source_len_bytes - // store new target length - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP4 << eth::Instruction::SSTORE; + retrieveLength(_targetType); + m_context << eth::Instruction::SWAP2; + // stack: target_ref target_len target_ref source_ref + retrieveLength(_sourceType); + // stack: target_ref target_len target_ref source_ref source_len + if (_targetType.isDynamicallySized()) + // store new target length + m_context << eth::Instruction::DUP1 << eth::Instruction::DUP4 << eth::Instruction::SSTORE; // compute hashes (data positions) m_context << eth::Instruction::SWAP2; - CompilerUtils(m_context).computeHashStatic(); + if (_targetType.isDynamicallySized()) + CompilerUtils(m_context).computeHashStatic(); m_context << eth::Instruction::SWAP1; - CompilerUtils(m_context).computeHashStatic(); - // stack: target_ref target_len_bytes source_len_bytes target_data_pos source_data_pos - // convert lengthes from bytes to storage slots - m_context << u256(31) << u256(32) << eth::Instruction::DUP1 << eth::Instruction::DUP3 - << eth::Instruction::DUP8 << eth::Instruction::ADD << eth::Instruction::DIV - << eth::Instruction::SWAP2 - << eth::Instruction::DUP6 << eth::Instruction::ADD << eth::Instruction::DIV; - // stack: target_ref target_len_bytes source_len_bytes target_data_pos source_data_pos target_len source_len + if (_sourceType.isDynamicallySized()) + CompilerUtils(m_context).computeHashStatic(); + // stack: target_ref target_len source_len target_data_pos source_data_pos + m_context << eth::Instruction::DUP4; + convertLengthToSize(_sourceType); + m_context << eth::Instruction::DUP4; + convertLengthToSize(_sourceType); + // stack: target_ref target_len source_len target_data_pos source_data_pos target_size source_size // @todo we might be able to go without a third counter m_context << u256(0); - // stack: target_ref target_len_bytes source_len_bytes target_data_pos source_data_pos target_len source_len counter + // stack: target_ref target_len source_len target_data_pos source_data_pos target_size source_size counter eth::AssemblyItem copyLoopStart = m_context.newTag(); m_context << copyLoopStart; // check for loop condition @@ -129,27 +140,28 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons eth::AssemblyItem copyLoopEnd = m_context.newTag(); m_context.appendConditionalJumpTo(copyLoopEnd); // copy - m_context << eth::Instruction::DUP4 << eth::Instruction::DUP2 << eth::Instruction::ADD - << eth::Instruction::SLOAD - << eth::Instruction::DUP6 << eth::Instruction::DUP3 << eth::Instruction::ADD - << eth::Instruction::SSTORE; + m_context << eth::Instruction::DUP4 << eth::Instruction::DUP2 << eth::Instruction::ADD; + StorageItem(m_context, *sourceBaseType).retrieveValue(SourceLocation(), true); + m_context << eth::dupInstruction(5 + sourceBaseType->getSizeOnStack()) + << eth::dupInstruction(2 + sourceBaseType->getSizeOnStack()) << eth::Instruction::ADD; + StorageItem(m_context, *targetBaseType).storeValue(*sourceBaseType, SourceLocation(), true); // increment - m_context << u256(1) << eth::Instruction::ADD; + m_context << targetBaseType->getStorageSize() << eth::Instruction::ADD; m_context.appendJumpTo(copyLoopStart); m_context << copyLoopEnd; // zero-out leftovers in target - // stack: target_ref target_len_bytes source_len_bytes target_data_pos source_data_pos target_len source_len counter + // stack: target_ref target_len source_len target_data_pos source_data_pos target_size source_size counter // add counter to target_data_pos m_context << eth::Instruction::DUP5 << eth::Instruction::ADD << eth::Instruction::SWAP5 << eth::Instruction::POP; - // stack: target_ref target_len_bytes target_data_pos_updated target_data_pos source_data_pos target_len source_len - // add length to target_data_pos to get target_data_end + // stack: target_ref target_len target_data_pos_updated target_data_pos source_data_pos target_size source_size + // add size to target_data_pos to get target_data_end m_context << eth::Instruction::POP << eth::Instruction::DUP3 << eth::Instruction::ADD << eth::Instruction::SWAP4 << eth::Instruction::POP << eth::Instruction::POP << eth::Instruction::POP; // stack: target_ref target_data_end target_data_pos_updated - clearStorageLoop(IntegerType(256)); + clearStorageLoop(*targetBaseType); m_context << eth::Instruction::POP; break; } @@ -282,3 +294,11 @@ void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType) const m_context << _arrayType.getBaseType()->getStorageSize() << eth::Instruction::MUL; } +void ArrayUtils::retrieveLength(ArrayType const& _arrayType) const +{ + if (_arrayType.isDynamicallySized()) + m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD; + else + m_context << _arrayType.getLength(); +} + diff --git a/libsolidity/ArrayUtils.h b/libsolidity/ArrayUtils.h index f080dce66..73e88340e 100644 --- a/libsolidity/ArrayUtils.h +++ b/libsolidity/ArrayUtils.h @@ -39,7 +39,8 @@ class ArrayUtils public: ArrayUtils(CompilerContext& _context): m_context(_context) {} - /// Copies an array to an array in storage. + /// Copies an array to an array in storage. The arrays can be of different types only if + /// their storage representation is the same. /// Stack pre: [source_reference] target_reference /// Stack post: target_reference void copyArrayToStorage(ArrayType const& _targetType, ArrayType const& _sourceType) const; @@ -63,6 +64,11 @@ public: /// Stack pre: length /// Stack post: size void convertLengthToSize(ArrayType const& _arrayType) const; + /// Retrieves the length (number of elements) of the array ref on the stack. This also + /// works for statically-sized arrays. + /// Stack pre: reference + /// Stack post: reference length + void retrieveLength(ArrayType const& _arrayType) const; private: CompilerContext& m_context; diff --git a/test/SolidityEndToEndTest.cpp b/test/SolidityEndToEndTest.cpp index 5b99f72e0..f305e81e3 100644 --- a/test/SolidityEndToEndTest.cpp +++ b/test/SolidityEndToEndTest.cpp @@ -2858,6 +2858,94 @@ BOOST_AUTO_TEST_CASE(dynamic_multi_array_cleanup) BOOST_CHECK(m_state.storage(m_contractAddress).empty()); } +BOOST_AUTO_TEST_CASE(array_copy_storage_storage_dyn_dyn) +{ + char const* sourceCode = R"( + contract c { + uint[] data1; + uint[] data2; + function setData1(uint length, uint index, uint value) { + data1.length = length; if (index < length) data1[index] = value; + } + function copyStorageStorage() { data2 = data1; } + function getData2(uint index) returns (uint len, uint val) { + len = data2.length; if (index < len) val = data2[index]; + } + } + )"; + compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("setData1(uint256,uint256,uint256)", 10, 5, 4) == bytes()); + BOOST_CHECK(callContractFunction("copyStorageStorage()") == bytes()); + BOOST_CHECK(callContractFunction("getData2(uint256)", 5) == encodeArgs(10, 4)); + BOOST_CHECK(callContractFunction("setData1(uint256,uint256,uint256)", 0, 0, 0) == bytes()); + BOOST_CHECK(callContractFunction("copyStorageStorage()") == bytes()); + BOOST_CHECK(callContractFunction("getData2(uint256)", 0) == encodeArgs(0, 0)); + BOOST_CHECK(m_state.storage(m_contractAddress).empty()); +} + +BOOST_AUTO_TEST_CASE(array_copy_storage_storage_static_static) +{ + char const* sourceCode = R"( + contract c { + uint[40] data1; + uint[20] data2; + function test() returns (uint x, uint y){ + data1[30] = 4; + data1[2] = 7; + data1[3] = 9; + data2[3] = 8; + data1 = data2; + x = data1[3]; + y = data1[30]; // should be cleared + } + } + )"; + compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("test()") == encodeArgs(8, 0)); +} + +BOOST_AUTO_TEST_CASE(array_copy_storage_storage_static_dynamic) +{ + char const* sourceCode = R"( + contract c { + uint[9] data1; + uint[] data2; + function test() returns (uint x, uint y){ + data1[8] = 4; + data2 = data1; + x = data2.length; + y = data2[8]; + } + } + )"; + compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("test()") == encodeArgs(9, 4)); +} + +BOOST_AUTO_TEST_CASE(array_copy_storage_storage_struct) +{ + char const* sourceCode = R"( + contract c { + struct Data { uint x; uint y; } + Data[] data1; + Data[] data2; + function test() returns (uint x, uint y) { + data1.length = 9; + data1[8].x = 4; + data1[8].y = 5; + data2 = data1; + x = data2[8].x; + y = data2[8].y; + data1.length = 0; + data2 = data1; + } + } + )"; + compileAndRun(sourceCode); + BOOST_CHECK(callContractFunction("test()") == encodeArgs(4, 5)); + BOOST_CHECK(m_state.storage(m_contractAddress).empty()); +} + BOOST_AUTO_TEST_SUITE_END() }