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

Convert ArrayUtils routines into low-level functions.

Browse Source
This commit is contained in:
chriseth 2017-01-20 14:19:25 +01:00
parent b60623521f
commit cea020b89e
1 changed files with 248 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
libsolidity/codegen/ArrayUtils.cpp
View File

@ -40,9 +40,9 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
// stack layout: [source_ref] [source length] target_ref (top) // stack layout: [source_ref] [source length] target_ref (top)
solAssert(_targetType.location() == DataLocation::Storage, ""); solAssert(_targetType.location() == DataLocation::Storage, "");
IntegerType uint256(256); TypePointer uint256 = make_shared<IntegerType>(256);
Type const* targetBaseType = _targetType.isByteArray() ? &uint256 : &(*_targetType.baseType()); TypePointer targetBaseType = _targetType.isByteArray() ? uint256 : _targetType.baseType();
Type const* sourceBaseType = _sourceType.isByteArray() ? &uint256 : &(*_sourceType.baseType()); TypePointer sourceBaseType = _sourceType.isByteArray() ? uint256 : _sourceType.baseType();
// TODO unroll loop for small sizes // TODO unroll loop for small sizes
@ -70,115 +70,127 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
} }
// stack: target_ref source_ref source_length // stack: target_ref source_ref source_length
m_context << Instruction::DUP3; TypePointer targetType = _targetType.shared_from_this();
TypePointer sourceType = _sourceType.shared_from_this();
m_context.callLowLevelFunction(
"$copyArrayToStorage_" + sourceType->identifier() + "_to_" + targetType->identifier(),
3,
1,
[=](CompilerContext& _context)
{
ArrayUtils utils(_context);
ArrayType const& _sourceType = dynamic_cast<ArrayType const&>(*sourceType);
ArrayType const& _targetType = dynamic_cast<ArrayType const&>(*targetType);
// stack: target_ref source_ref source_length
_context << Instruction::DUP3;
// stack: target_ref source_ref source_length target_ref // stack: target_ref source_ref source_length target_ref
retrieveLength(_targetType); utils.retrieveLength(_targetType);
// stack: target_ref source_ref source_length target_ref target_length // stack: target_ref source_ref source_length target_ref target_length
if (_targetType.isDynamicallySized()) if (_targetType.isDynamicallySized())
// store new target length // store new target length
if (!_targetType.isByteArray()) if (!_targetType.isByteArray())
// Otherwise, length will be stored below. // Otherwise, length will be stored below.
m_context << Instruction::DUP3 << Instruction::DUP3 << Instruction::SSTORE; _context << Instruction::DUP3 << Instruction::DUP3 << Instruction::SSTORE;
if (sourceBaseType->category() == Type::Category::Mapping) if (sourceBaseType->category() == Type::Category::Mapping)
{ {
solAssert(targetBaseType->category() == Type::Category::Mapping, ""); solAssert(targetBaseType->category() == Type::Category::Mapping, "");
solAssert(_sourceType.location() == DataLocation::Storage, ""); solAssert(_sourceType.location() == DataLocation::Storage, "");
// nothing to copy // nothing to copy
m_context _context
<< Instruction::POP << Instruction::POP << Instruction::POP << Instruction::POP
<< Instruction::POP << Instruction::POP; << Instruction::POP << Instruction::POP;
return; return;
} }
// stack: target_ref source_ref source_length target_ref target_length // stack: target_ref source_ref source_length target_ref target_length
// compute hashes (data positions) // compute hashes (data positions)
m_context << Instruction::SWAP1; _context << Instruction::SWAP1;
if (_targetType.isDynamicallySized()) if (_targetType.isDynamicallySized())
CompilerUtils(m_context).computeHashStatic(); CompilerUtils(_context).computeHashStatic();
// stack: target_ref source_ref source_length target_length target_data_pos // stack: target_ref source_ref source_length target_length target_data_pos
m_context << Instruction::SWAP1; _context << Instruction::SWAP1;
convertLengthToSize(_targetType); utils.convertLengthToSize(_targetType);
m_context << Instruction::DUP2 << Instruction::ADD; _context << Instruction::DUP2 << Instruction::ADD;
// stack: target_ref source_ref source_length target_data_pos target_data_end // stack: target_ref source_ref source_length target_data_pos target_data_end
m_context << Instruction::SWAP3; _context << Instruction::SWAP3;
// stack: target_ref target_data_end source_length target_data_pos source_ref // stack: target_ref target_data_end source_length target_data_pos source_ref
eth::AssemblyItem copyLoopEndWithoutByteOffset = m_context.newTag(); eth::AssemblyItem copyLoopEndWithoutByteOffset = _context.newTag();
// special case for short byte arrays: Store them together with their length. // special case for short byte arrays: Store them together with their length.
if (_targetType.isByteArray()) if (_targetType.isByteArray())
{ {
// stack: target_ref target_data_end source_length target_data_pos source_ref // stack: target_ref target_data_end source_length target_data_pos source_ref
m_context << Instruction::DUP3 << u256(31) << Instruction::LT; _context << Instruction::DUP3 << u256(31) << Instruction::LT;
eth::AssemblyItem longByteArray = m_context.appendConditionalJump(); eth::AssemblyItem longByteArray = _context.appendConditionalJump();
// store the short byte array // store the short byte array
solAssert(_sourceType.isByteArray(), ""); solAssert(_sourceType.isByteArray(), "");
if (_sourceType.location() == DataLocation::Storage) if (_sourceType.location() == DataLocation::Storage)
{ {
// just copy the slot, it contains length and data // just copy the slot, it contains length and data
m_context << Instruction::DUP1 << Instruction::SLOAD; _context << Instruction::DUP1 << Instruction::SLOAD;
m_context << Instruction::DUP6 << Instruction::SSTORE; _context << Instruction::DUP6 << Instruction::SSTORE;
} }
else else
{ {
m_context << Instruction::DUP1; _context << Instruction::DUP1;
CompilerUtils(m_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false); CompilerUtils(_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false);
// stack: target_ref target_data_end source_length target_data_pos source_ref value // stack: target_ref target_data_end source_length target_data_pos source_ref value
// clear the lower-order byte - which will hold the length // clear the lower-order byte - which will hold the length
m_context << u256(0xff) << Instruction::NOT << Instruction::AND; _context << u256(0xff) << Instruction::NOT << Instruction::AND;
// fetch the length and shift it left by one // fetch the length and shift it left by one
m_context << Instruction::DUP4 << Instruction::DUP1 << Instruction::ADD; _context << Instruction::DUP4 << Instruction::DUP1 << Instruction::ADD;
// combine value and length and store them // combine value and length and store them
m_context << Instruction::OR << Instruction::DUP6 << Instruction::SSTORE; _context << Instruction::OR << Instruction::DUP6 << Instruction::SSTORE;
} }
// end of special case, jump right into cleaning target data area // end of special case, jump right into cleaning target data area
m_context.appendJumpTo(copyLoopEndWithoutByteOffset); _context.appendJumpTo(copyLoopEndWithoutByteOffset);
m_context << longByteArray; _context << longByteArray;
// Store length (2*length+1) // Store length (2*length+1)
m_context << Instruction::DUP3 << Instruction::DUP1 << Instruction::ADD; _context << Instruction::DUP3 << Instruction::DUP1 << Instruction::ADD;
m_context << u256(1) << Instruction::ADD; _context << u256(1) << Instruction::ADD;
m_context << Instruction::DUP6 << Instruction::SSTORE; _context << Instruction::DUP6 << Instruction::SSTORE;
} }
// skip copying if source length is zero // skip copying if source length is zero
m_context << Instruction::DUP3 << Instruction::ISZERO; _context << Instruction::DUP3 << Instruction::ISZERO;
m_context.appendConditionalJumpTo(copyLoopEndWithoutByteOffset); _context.appendConditionalJumpTo(copyLoopEndWithoutByteOffset);
if (_sourceType.location() == DataLocation::Storage && _sourceType.isDynamicallySized()) if (_sourceType.location() == DataLocation::Storage && _sourceType.isDynamicallySized())
CompilerUtils(m_context).computeHashStatic(); CompilerUtils(_context).computeHashStatic();
// stack: target_ref target_data_end source_length target_data_pos source_data_pos // stack: target_ref target_data_end source_length target_data_pos source_data_pos
m_context << Instruction::SWAP2; _context << Instruction::SWAP2;
convertLengthToSize(_sourceType); utils.convertLengthToSize(_sourceType);
m_context << Instruction::DUP3 << Instruction::ADD; _context << Instruction::DUP3 << Instruction::ADD;
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end
if (haveByteOffsetTarget) if (haveByteOffsetTarget)
m_context << u256(0); _context << u256(0);
if (haveByteOffsetSource) if (haveByteOffsetSource)
m_context << u256(0); _context << u256(0);
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
eth::AssemblyItem copyLoopStart = m_context.newTag(); eth::AssemblyItem copyLoopStart = _context.newTag();
m_context << copyLoopStart; _context << copyLoopStart;
// check for loop condition // check for loop condition
m_context _context
<< dupInstruction(3 + byteOffsetSize) << dupInstruction(2 + byteOffsetSize) << dupInstruction(3 + byteOffsetSize) << dupInstruction(2 + byteOffsetSize)
<< Instruction::GT << Instruction::ISZERO; << Instruction::GT << Instruction::ISZERO;
eth::AssemblyItem copyLoopEnd = m_context.appendConditionalJump(); eth::AssemblyItem copyLoopEnd = _context.appendConditionalJump();
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
// copy // copy
if (sourceBaseType->category() == Type::Category::Array) if (sourceBaseType->category() == Type::Category::Array)
{ {
solAssert(byteOffsetSize == 0, "Byte offset for array as base type."); solAssert(byteOffsetSize == 0, "Byte offset for array as base type.");
auto const& sourceBaseArrayType = dynamic_cast<ArrayType const&>(*sourceBaseType); auto const& sourceBaseArrayType = dynamic_cast<ArrayType const&>(*sourceBaseType);
m_context << Instruction::DUP3; _context << Instruction::DUP3;
if (sourceBaseArrayType.location() == DataLocation::Memory) if (sourceBaseArrayType.location() == DataLocation::Memory)
m_context << Instruction::MLOAD; _context << Instruction::MLOAD;
m_context << Instruction::DUP3; _context << Instruction::DUP3;
copyArrayToStorage(dynamic_cast<ArrayType const&>(*targetBaseType), sourceBaseArrayType); utils.copyArrayToStorage(dynamic_cast<ArrayType const&>(*targetBaseType), sourceBaseArrayType);
m_context << Instruction::POP; _context << Instruction::POP;
} }
else if (directCopy) else if (directCopy)
{ {
solAssert(byteOffsetSize == 0, "Byte offset for direct copy."); solAssert(byteOffsetSize == 0, "Byte offset for direct copy.");
m_context _context
<< Instruction::DUP3 << Instruction::SLOAD << Instruction::DUP3 << Instruction::SLOAD
<< Instruction::DUP3 << Instruction::SSTORE; << Instruction::DUP3 << Instruction::SSTORE;
} }
@ -188,17 +200,17 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
// We might copy too much if there is padding at the last element, but this way end // We might copy too much if there is padding at the last element, but this way end
// checking is easier. // checking is easier.
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
m_context << dupInstruction(3 + byteOffsetSize); _context << dupInstruction(3 + byteOffsetSize);
if (_sourceType.location() == DataLocation::Storage) if (_sourceType.location() == DataLocation::Storage)
{ {
if (haveByteOffsetSource) if (haveByteOffsetSource)
m_context << Instruction::DUP2; _context << Instruction::DUP2;
else else
m_context << u256(0); _context << u256(0);
StorageItem(m_context, *sourceBaseType).retrieveValue(SourceLocation(), true); StorageItem(_context, *sourceBaseType).retrieveValue(SourceLocation(), true);
} }
else if (sourceBaseType->isValueType()) else if (sourceBaseType->isValueType())
CompilerUtils(m_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false); CompilerUtils(_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false);
else else
solUnimplemented("Copying of type " + _sourceType.toString(false) + " to storage not yet supported."); solUnimplemented("Copying of type " + _sourceType.toString(false) + " to storage not yet supported.");
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] <source_value>... // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] <source_value>...
@ -207,65 +219,67 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
"Stack too deep, try removing local variables." "Stack too deep, try removing local variables."
); );
// fetch target storage reference // fetch target storage reference
m_context << dupInstruction(2 + byteOffsetSize + sourceBaseType->sizeOnStack()); _context << dupInstruction(2 + byteOffsetSize + sourceBaseType->sizeOnStack());
if (haveByteOffsetTarget) if (haveByteOffsetTarget)
m_context << dupInstruction(1 + byteOffsetSize + sourceBaseType->sizeOnStack()); _context << dupInstruction(1 + byteOffsetSize + sourceBaseType->sizeOnStack());
else else
m_context << u256(0); _context << u256(0);
StorageItem(m_context, *targetBaseType).storeValue(*sourceBaseType, SourceLocation(), true); StorageItem(_context, *targetBaseType).storeValue(*sourceBaseType, SourceLocation(), true);
} }
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
// increment source // increment source
if (haveByteOffsetSource) if (haveByteOffsetSource)
incrementByteOffset(sourceBaseType->storageBytes(), 1, haveByteOffsetTarget ? 5 : 4); utils.incrementByteOffset(sourceBaseType->storageBytes(), 1, haveByteOffsetTarget ? 5 : 4);
else else
{ {
m_context << swapInstruction(2 + byteOffsetSize); _context << swapInstruction(2 + byteOffsetSize);
if (sourceIsStorage) if (sourceIsStorage)
m_context << sourceBaseType->storageSize(); _context << sourceBaseType->storageSize();
else if (_sourceType.location() == DataLocation::Memory) else if (_sourceType.location() == DataLocation::Memory)
m_context << sourceBaseType->memoryHeadSize(); _context << sourceBaseType->memoryHeadSize();
else else
m_context << sourceBaseType->calldataEncodedSize(true); _context << sourceBaseType->calldataEncodedSize(true);
m_context _context
<< Instruction::ADD << Instruction::ADD
<< swapInstruction(2 + byteOffsetSize); << swapInstruction(2 + byteOffsetSize);
} }
// increment target // increment target
if (haveByteOffsetTarget) if (haveByteOffsetTarget)
incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2); utils.incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2);
else else
m_context _context
<< swapInstruction(1 + byteOffsetSize) << swapInstruction(1 + byteOffsetSize)
<< targetBaseType->storageSize() << targetBaseType->storageSize()
<< Instruction::ADD << Instruction::ADD
<< swapInstruction(1 + byteOffsetSize); << swapInstruction(1 + byteOffsetSize);
m_context.appendJumpTo(copyLoopStart); _context.appendJumpTo(copyLoopStart);
m_context << copyLoopEnd; _context << copyLoopEnd;
if (haveByteOffsetTarget) if (haveByteOffsetTarget)
{ {
// clear elements that might be left over in the current slot in target // clear elements that might be left over in the current slot in target
// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end target_byte_offset [source_byte_offset] // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end target_byte_offset [source_byte_offset]
m_context << dupInstruction(byteOffsetSize) << Instruction::ISZERO; _context << dupInstruction(byteOffsetSize) << Instruction::ISZERO;
eth::AssemblyItem copyCleanupLoopEnd = m_context.appendConditionalJump(); eth::AssemblyItem copyCleanupLoopEnd = _context.appendConditionalJump();
m_context << dupInstruction(2 + byteOffsetSize) << dupInstruction(1 + byteOffsetSize); _context << dupInstruction(2 + byteOffsetSize) << dupInstruction(1 + byteOffsetSize);
StorageItem(m_context, *targetBaseType).setToZero(SourceLocation(), true); StorageItem(_context, *targetBaseType).setToZero(SourceLocation(), true);
incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2); utils.incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2);
m_context.appendJumpTo(copyLoopEnd); _context.appendJumpTo(copyLoopEnd);
m_context << copyCleanupLoopEnd; _context << copyCleanupLoopEnd;
m_context << Instruction::POP; // might pop the source, but then target is popped next _context << Instruction::POP; // might pop the source, but then target is popped next
} }
if (haveByteOffsetSource) if (haveByteOffsetSource)
m_context << Instruction::POP; _context << Instruction::POP;
m_context << copyLoopEndWithoutByteOffset; _context << copyLoopEndWithoutByteOffset;
// zero-out leftovers in target // zero-out leftovers in target
// stack: target_ref target_data_end source_data_pos target_data_pos_updated source_data_end // stack: target_ref target_data_end source_data_pos target_data_pos_updated source_data_end
m_context << Instruction::POP << Instruction::SWAP1 << Instruction::POP; _context << Instruction::POP << Instruction::SWAP1 << Instruction::POP;
// stack: target_ref target_data_end target_data_pos_updated // stack: target_ref target_data_end target_data_pos_updated
clearStorageLoop(*targetBaseType); utils.clearStorageLoop(*targetBaseType);
m_context << Instruction::POP; _context << Instruction::POP;
}
);
} }
void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWordBoundaries) const void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWordBoundaries) const
@ -759,41 +773,50 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _typeIn) const
void ArrayUtils::clearStorageLoop(Type const& _type) const void ArrayUtils::clearStorageLoop(Type const& _type) const
{ {
unsigned stackHeightStart = m_context.stackHeight(); TypePointer type = _type.shared_from_this();
if (_type.category() == Type::Category::Mapping) m_context.callLowLevelFunction(
"$clearStorageLoop_" + _type.identifier(),
2,
1,
[type](CompilerContext& _context)
{ {
m_context << Instruction::POP; unsigned stackHeightStart = _context.stackHeight();
if (type->category() == Type::Category::Mapping)
{
_context << Instruction::POP;
return; return;
} }
// stack: end_pos pos // stack: end_pos pos
// jump to and return from the loop to allow for duplicate code removal // jump to and return from the loop to allow for duplicate code removal
eth::AssemblyItem returnTag = m_context.pushNewTag(); eth::AssemblyItem returnTag = _context.pushNewTag();
m_context << Instruction::SWAP2 << Instruction::SWAP1; _context << Instruction::SWAP2 << Instruction::SWAP1;
// stack: <return tag> end_pos pos // stack: <return tag> end_pos pos
eth::AssemblyItem loopStart = m_context.appendJumpToNew(); eth::AssemblyItem loopStart = _context.appendJumpToNew();
m_context << loopStart; _context << loopStart;
// check for loop condition // check for loop condition
m_context << Instruction::DUP1 << Instruction::DUP3 _context << Instruction::DUP1 << Instruction::DUP3
<< Instruction::GT << Instruction::ISZERO; << Instruction::GT << Instruction::ISZERO;
eth::AssemblyItem zeroLoopEnd = m_context.newTag(); eth::AssemblyItem zeroLoopEnd = _context.newTag();
m_context.appendConditionalJumpTo(zeroLoopEnd); _context.appendConditionalJumpTo(zeroLoopEnd);
// delete // delete
m_context << u256(0); _context << u256(0);
StorageItem(m_context, _type).setToZero(SourceLocation(), false); StorageItem(_context, *type).setToZero(SourceLocation(), false);
m_context << Instruction::POP; _context << Instruction::POP;
// increment // increment
m_context << _type.storageSize() << Instruction::ADD; _context << type->storageSize() << Instruction::ADD;
m_context.appendJumpTo(loopStart); _context.appendJumpTo(loopStart);
// cleanup // cleanup
m_context << zeroLoopEnd; _context << zeroLoopEnd;
m_context << Instruction::POP << Instruction::SWAP1; _context << Instruction::POP << Instruction::SWAP1;
// "return" // "return"
m_context << Instruction::JUMP; _context << Instruction::JUMP;
m_context << returnTag; _context << returnTag;
solAssert(m_context.stackHeight() == stackHeightStart - 1, ""); solAssert(_context.stackHeight() == stackHeightStart - 1, "");
}
);
} }
void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType, bool _pad) const void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType, bool _pad) const