/*
	This file is part of solidity.

	solidity is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	solidity is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
 * @author Christian <c@ethdev.com>
 * @date 2015
 * Code generation utils that handle arrays.
 */

#include <libsolidity/codegen/ArrayUtils.h>

#include <libsolidity/ast/Types.h>
#include <libsolidity/ast/TypeProvider.h>
#include <libsolidity/codegen/CompilerContext.h>
#include <libsolidity/codegen/CompilerUtils.h>
#include <libsolidity/codegen/LValue.h>

#include <libevmasm/Instruction.h>
#include <liblangutil/Exceptions.h>

using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace langutil;
using namespace dev::solidity;

void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType const& _sourceType) const
{
	// this copies source to target and also clears target if it was larger
	// need to leave "target_ref target_byte_off" on the stack at the end

	// stack layout: [source_ref] [source length] target_ref (top)
	solAssert(_targetType.location() == DataLocation::Storage, "");

	TypePointer uint256 = TypeProvider::uint256();
	TypePointer targetBaseType = _targetType.isByteArray() ? uint256 : _targetType.baseType();
	TypePointer sourceBaseType = _sourceType.isByteArray() ? uint256 : _sourceType.baseType();

	// TODO unroll loop for small sizes

	bool sourceIsStorage = _sourceType.location() == DataLocation::Storage;
	bool fromCalldata = _sourceType.location() == DataLocation::CallData;
	bool directCopy = sourceIsStorage && sourceBaseType->isValueType() && *sourceBaseType == *targetBaseType;
	bool haveByteOffsetSource = !directCopy && sourceIsStorage && sourceBaseType->storageBytes() <= 16;
	bool haveByteOffsetTarget = !directCopy && targetBaseType->storageBytes() <= 16;
	unsigned byteOffsetSize = (haveByteOffsetSource ? 1 : 0) + (haveByteOffsetTarget ? 1 : 0);

	// stack: source_ref [source_length] target_ref
	// store target_ref
	for (unsigned i = _sourceType.sizeOnStack(); i > 0; --i)
		m_context << swapInstruction(i);
	// stack: target_ref source_ref [source_length]
	// stack: target_ref source_ref [source_length]
	// retrieve source length
	if (_sourceType.location() != DataLocation::CallData || !_sourceType.isDynamicallySized())
		retrieveLength(_sourceType); // otherwise, length is already there
	if (_sourceType.location() == DataLocation::Memory && _sourceType.isDynamicallySized())
	{
		// increment source pointer to point to data
		m_context << Instruction::SWAP1 << u256(0x20);
		m_context << Instruction::ADD << Instruction::SWAP1;
	}

	// stack: target_ref source_ref source_length
	TypePointer targetType = &_targetType;
	TypePointer sourceType = &_sourceType;
	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
			utils.retrieveLength(_targetType);
			// stack: target_ref source_ref source_length target_ref target_length
			if (_targetType.isDynamicallySized())
				// store new target length
				if (!_targetType.isByteArray())
					// Otherwise, length will be stored below.
					_context << Instruction::DUP3 << Instruction::DUP3 << Instruction::SSTORE;
			if (sourceBaseType->category() == Type::Category::Mapping)
			{
				solAssert(targetBaseType->category() == Type::Category::Mapping, "");
				solAssert(_sourceType.location() == DataLocation::Storage, "");
				// nothing to copy
				_context
					<< Instruction::POP << Instruction::POP
					<< Instruction::POP << Instruction::POP;
				return;
			}
			// stack: target_ref source_ref source_length target_ref target_length
			// compute hashes (data positions)
			_context << Instruction::SWAP1;
			if (_targetType.isDynamicallySized())
				CompilerUtils(_context).computeHashStatic();
			// stack: target_ref source_ref source_length target_length target_data_pos
			_context << Instruction::SWAP1;
			utils.convertLengthToSize(_targetType);
			_context << Instruction::DUP2 << Instruction::ADD;
			// stack: target_ref source_ref source_length target_data_pos target_data_end
			_context << Instruction::SWAP3;
			// stack: target_ref target_data_end source_length target_data_pos source_ref

			eth::AssemblyItem copyLoopEndWithoutByteOffset = _context.newTag();

			// special case for short byte arrays: Store them together with their length.
			if (_targetType.isByteArray())
			{
				// stack: target_ref target_data_end source_length target_data_pos source_ref
				_context << Instruction::DUP3 << u256(31) << Instruction::LT;
				eth::AssemblyItem longByteArray = _context.appendConditionalJump();
				// store the short byte array
				solAssert(_sourceType.isByteArray(), "");
				if (_sourceType.location() == DataLocation::Storage)
				{
					// just copy the slot, it contains length and data
					_context << Instruction::DUP1 << Instruction::SLOAD;
					_context << Instruction::DUP6 << Instruction::SSTORE;
				}
				else
				{
					_context << Instruction::DUP1;
					CompilerUtils(_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false);
					// stack: target_ref target_data_end source_length target_data_pos source_ref value
					// clear the lower-order byte - which will hold the length
					_context << u256(0xff) << Instruction::NOT << Instruction::AND;
					// fetch the length and shift it left by one
					_context << Instruction::DUP4 << Instruction::DUP1 << Instruction::ADD;
					// combine value and length and store them
					_context << Instruction::OR << Instruction::DUP6 << Instruction::SSTORE;
				}
				// end of special case, jump right into cleaning target data area
				_context.appendJumpTo(copyLoopEndWithoutByteOffset);
				_context << longByteArray;
				// Store length (2*length+1)
				_context << Instruction::DUP3 << Instruction::DUP1 << Instruction::ADD;
				_context << u256(1) << Instruction::ADD;
				_context << Instruction::DUP6 << Instruction::SSTORE;
			}

			// skip copying if source length is zero
			_context << Instruction::DUP3 << Instruction::ISZERO;
			_context.appendConditionalJumpTo(copyLoopEndWithoutByteOffset);

			if (_sourceType.location() == DataLocation::Storage && _sourceType.isDynamicallySized())
				CompilerUtils(_context).computeHashStatic();
			// stack: target_ref target_data_end source_length target_data_pos source_data_pos
			_context << Instruction::SWAP2;
			utils.convertLengthToSize(_sourceType);
			_context << Instruction::DUP3 << Instruction::ADD;
			// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end
			if (haveByteOffsetTarget)
				_context << u256(0);
			if (haveByteOffsetSource)
				_context << u256(0);
			// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
			eth::AssemblyItem copyLoopStart = _context.newTag();
			_context << copyLoopStart;
			// check for loop condition
			_context
				<< dupInstruction(3 + byteOffsetSize) << dupInstruction(2 + byteOffsetSize)
				<< Instruction::GT << Instruction::ISZERO;
			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]
			// copy
			if (sourceBaseType->category() == Type::Category::Array)
			{
				solAssert(byteOffsetSize == 0, "Byte offset for array as base type.");
				auto const& sourceBaseArrayType = dynamic_cast<ArrayType const&>(*sourceBaseType);
				_context << Instruction::DUP3;
				if (sourceBaseArrayType.location() == DataLocation::Memory)
					_context << Instruction::MLOAD;
				_context << Instruction::DUP3;
				utils.copyArrayToStorage(dynamic_cast<ArrayType const&>(*targetBaseType), sourceBaseArrayType);
				_context << Instruction::POP;
			}
			else if (directCopy)
			{
				solAssert(byteOffsetSize == 0, "Byte offset for direct copy.");
				_context
					<< Instruction::DUP3 << Instruction::SLOAD
					<< Instruction::DUP3 << Instruction::SSTORE;
			}
			else
			{
				// Note that we have to copy each element on its own in case conversion is involved.
				// We might copy too much if there is padding at the last element, but this way end
				// checking is easier.
				// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
				_context << dupInstruction(3 + byteOffsetSize);
				if (_sourceType.location() == DataLocation::Storage)
				{
					if (haveByteOffsetSource)
						_context << Instruction::DUP2;
					else
						_context << u256(0);
					StorageItem(_context, *sourceBaseType).retrieveValue(SourceLocation(), true);
				}
				else if (sourceBaseType->isValueType())
					CompilerUtils(_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false);
				else
					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>...
				solAssert(
					2 + byteOffsetSize + sourceBaseType->sizeOnStack() <= 16,
					"Stack too deep, try removing local variables."
				);
				// fetch target storage reference
				_context << dupInstruction(2 + byteOffsetSize + sourceBaseType->sizeOnStack());
				if (haveByteOffsetTarget)
					_context << dupInstruction(1 + byteOffsetSize + sourceBaseType->sizeOnStack());
				else
					_context << u256(0);
				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]
			// increment source
			if (haveByteOffsetSource)
				utils.incrementByteOffset(sourceBaseType->storageBytes(), 1, haveByteOffsetTarget ? 5 : 4);
			else
			{
				_context << swapInstruction(2 + byteOffsetSize);
				if (sourceIsStorage)
					_context << sourceBaseType->storageSize();
				else if (_sourceType.location() == DataLocation::Memory)
					_context << sourceBaseType->memoryHeadSize();
				else
					_context << sourceBaseType->calldataEncodedSize(true);
				_context
					<< Instruction::ADD
					<< swapInstruction(2 + byteOffsetSize);
			}
			// increment target
			if (haveByteOffsetTarget)
				utils.incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2);
			else
				_context
					<< swapInstruction(1 + byteOffsetSize)
					<< targetBaseType->storageSize()
					<< Instruction::ADD
					<< swapInstruction(1 + byteOffsetSize);
			_context.appendJumpTo(copyLoopStart);
			_context << copyLoopEnd;
			if (haveByteOffsetTarget)
			{
				// 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]
				_context << dupInstruction(byteOffsetSize) << Instruction::ISZERO;
				eth::AssemblyItem copyCleanupLoopEnd = _context.appendConditionalJump();
				_context << dupInstruction(2 + byteOffsetSize) << dupInstruction(1 + byteOffsetSize);
				StorageItem(_context, *targetBaseType).setToZero(SourceLocation(), true);
				utils.incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2);
				_context.appendJumpTo(copyLoopEnd);

				_context << copyCleanupLoopEnd;
				_context << Instruction::POP; // might pop the source, but then target is popped next
			}
			if (haveByteOffsetSource)
				_context << Instruction::POP;
			_context << copyLoopEndWithoutByteOffset;

			// zero-out leftovers in target
			// stack: target_ref target_data_end source_data_pos target_data_pos_updated source_data_end
			_context << Instruction::POP << Instruction::SWAP1 << Instruction::POP;
			// stack: target_ref target_data_end target_data_pos_updated
			utils.clearStorageLoop(targetBaseType);
			_context << Instruction::POP;
		}
	);
}

void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWordBoundaries) const
{
	solUnimplementedAssert(
		!_sourceType.baseType()->isDynamicallySized(),
		"Nested dynamic arrays not implemented here."
	);
	CompilerUtils utils(m_context);
	unsigned baseSize = 1;
	if (!_sourceType.isByteArray())
	{
		// We always pad the elements, regardless of _padToWordBoundaries.
		baseSize = _sourceType.baseType()->calldataEncodedSize();
		solAssert(baseSize >= 0x20, "");
	}

	if (_sourceType.location() == DataLocation::CallData)
	{
		if (!_sourceType.isDynamicallySized())
			m_context << _sourceType.length();
		if (baseSize > 1)
			m_context << u256(baseSize) << Instruction::MUL;

		string routine = "calldatacopy(target, source, len)\n";
		if (_padToWordBoundaries)
			routine += R"(
				// Set padding suffix to zero
				mstore(add(target, len), 0)
				len := and(add(len, 0x1f), not(0x1f))
			)";
		routine += "target := add(target, len)\n";
		m_context.appendInlineAssembly("{" + routine + "}", {"target", "source", "len"});
		m_context << Instruction::POP << Instruction::POP;
	}
	else if (_sourceType.location() == DataLocation::Memory)
	{
		retrieveLength(_sourceType);
		// stack: target source length
		if (!_sourceType.baseType()->isValueType())
		{
			// copy using a loop
			m_context << u256(0) << Instruction::SWAP3;
			// stack: counter source length target
			auto repeat = m_context.newTag();
			m_context << repeat;
			m_context << Instruction::DUP2 << Instruction::DUP5;
			m_context << Instruction::LT << Instruction::ISZERO;
			auto loopEnd = m_context.appendConditionalJump();
			m_context << Instruction::DUP3 << Instruction::DUP5;
			accessIndex(_sourceType, false);
			MemoryItem(m_context, *_sourceType.baseType(), true).retrieveValue(SourceLocation(), true);
			if (auto baseArray = dynamic_cast<ArrayType const*>(_sourceType.baseType()))
				copyArrayToMemory(*baseArray, _padToWordBoundaries);
			else
				utils.storeInMemoryDynamic(*_sourceType.baseType());
			m_context << Instruction::SWAP3 << u256(1) << Instruction::ADD;
			m_context << Instruction::SWAP3;
			m_context.appendJumpTo(repeat);
			m_context << loopEnd;
			m_context << Instruction::SWAP3;
			utils.popStackSlots(3);
			// stack: updated_target_pos
			return;
		}

		// memcpy using the built-in contract
		if (_sourceType.isDynamicallySized())
		{
			// change pointer to data part
			m_context << Instruction::SWAP1 << u256(32) << Instruction::ADD;
			m_context << Instruction::SWAP1;
		}
		// convert length to size
		if (baseSize > 1)
			m_context << u256(baseSize) << Instruction::MUL;
		// stack: <target> <source> <size>
		m_context << Instruction::DUP1 << Instruction::DUP4 << Instruction::DUP4;
		// We can resort to copying full 32 bytes only if
		// - the length is known to be a multiple of 32 or
		// - we will pad to full 32 bytes later anyway.
		if (((baseSize % 32) == 0) || _padToWordBoundaries)
			utils.memoryCopy32();
		else
			utils.memoryCopy();

		m_context << Instruction::SWAP1 << Instruction::POP;
		// stack: <target> <size>

		bool paddingNeeded = false;
		if (_sourceType.isDynamicallySized())
			paddingNeeded = _padToWordBoundaries && ((baseSize % 32) != 0);
		else
			paddingNeeded = _padToWordBoundaries && (((_sourceType.length() * baseSize) % 32) != 0);
		if (paddingNeeded)
		{
			// stack: <target> <size>
			m_context << Instruction::SWAP1 << Instruction::DUP2 << Instruction::ADD;
			// stack: <length> <target + size>
			m_context << Instruction::SWAP1 << u256(31) << Instruction::AND;
			// stack: <target + size> <remainder = size % 32>
			eth::AssemblyItem skip = m_context.newTag();
			if (_sourceType.isDynamicallySized())
			{
				m_context << Instruction::DUP1 << Instruction::ISZERO;
				m_context.appendConditionalJumpTo(skip);
			}
			// round off, load from there.
			// stack <target + size> <remainder = size % 32>
			m_context << Instruction::DUP1 << Instruction::DUP3;
			m_context << Instruction::SUB;
			// stack: target+size remainder <target + size - remainder>
			m_context << Instruction::DUP1 << Instruction::MLOAD;
			// Now we AND it with ~(2**(8 * (32 - remainder)) - 1)
			m_context << u256(1);
			m_context << Instruction::DUP4 << u256(32) << Instruction::SUB;
			// stack: ...<v> 1 <32 - remainder>
			m_context << u256(0x100) << Instruction::EXP << Instruction::SUB;
			m_context << Instruction::NOT << Instruction::AND;
			// stack: target+size remainder target+size-remainder <v & ...>
			m_context << Instruction::DUP2 << Instruction::MSTORE;
			// stack: target+size remainder target+size-remainder
			m_context << u256(32) << Instruction::ADD;
			// stack: target+size remainder <new_padded_end>
			m_context << Instruction::SWAP2 << Instruction::POP;

			if (_sourceType.isDynamicallySized())
				m_context << skip.tag();
			// stack <target + "size"> <remainder = size % 32>
			m_context << Instruction::POP;
		}
		else
			// stack: <target> <size>
			m_context << Instruction::ADD;
	}
	else
	{
		solAssert(_sourceType.location() == DataLocation::Storage, "");
		unsigned storageBytes = _sourceType.baseType()->storageBytes();
		u256 storageSize = _sourceType.baseType()->storageSize();
		solAssert(storageSize > 1 || (storageSize == 1 && storageBytes > 0), "");

		retrieveLength(_sourceType);
		// stack here: memory_offset storage_offset length
		// jump to end if length is zero
		m_context << Instruction::DUP1 << Instruction::ISZERO;
		eth::AssemblyItem loopEnd = m_context.appendConditionalJump();
		// Special case for tightly-stored byte arrays
		if (_sourceType.isByteArray())
		{
			// stack here: memory_offset storage_offset length
			m_context << Instruction::DUP1 << u256(31) << Instruction::LT;
			eth::AssemblyItem longByteArray = m_context.appendConditionalJump();
			// store the short byte array (discard lower-order byte)
			m_context << u256(0x100) << Instruction::DUP1;
			m_context << Instruction::DUP4 << Instruction::SLOAD;
			m_context << Instruction::DIV << Instruction::MUL;
			m_context << Instruction::DUP4 << Instruction::MSTORE;
			// stack here: memory_offset storage_offset length
			// add 32 or length to memory offset
			m_context << Instruction::SWAP2;
			if (_padToWordBoundaries)
				m_context << u256(32);
			else
				m_context << Instruction::DUP3;
			m_context << Instruction::ADD;
			m_context << Instruction::SWAP2;
			m_context.appendJumpTo(loopEnd);
			m_context << longByteArray;
		}
		// compute memory end offset
		if (baseSize > 1)
			// convert length to memory size
			m_context << u256(baseSize) << Instruction::MUL;
		m_context << Instruction::DUP3 << Instruction::ADD << Instruction::SWAP2;
		if (_sourceType.isDynamicallySized())
		{
			// actual array data is stored at KECCAK256(storage_offset)
			m_context << Instruction::SWAP1;
			utils.computeHashStatic();
			m_context << Instruction::SWAP1;
		}

		// stack here: memory_end_offset storage_data_offset memory_offset
		bool haveByteOffset = !_sourceType.isByteArray() && storageBytes <= 16;
		if (haveByteOffset)
			m_context << u256(0) << Instruction::SWAP1;
		// stack here: memory_end_offset storage_data_offset [storage_byte_offset] memory_offset
		eth::AssemblyItem loopStart = m_context.newTag();
		m_context << loopStart;
		// load and store
		if (_sourceType.isByteArray())
		{
			// Packed both in storage and memory.
			m_context << Instruction::DUP2 << Instruction::SLOAD;
			m_context << Instruction::DUP2 << Instruction::MSTORE;
			// increment storage_data_offset by 1
			m_context << Instruction::SWAP1 << u256(1) << Instruction::ADD;
			// increment memory offset by 32
			m_context << Instruction::SWAP1 << u256(32) << Instruction::ADD;
		}
		else
		{
			// stack here: memory_end_offset storage_data_offset [storage_byte_offset] memory_offset
			if (haveByteOffset)
				m_context << Instruction::DUP3 << Instruction::DUP3;
			else
				m_context << Instruction::DUP2 << u256(0);
			StorageItem(m_context, *_sourceType.baseType()).retrieveValue(SourceLocation(), true);
			if (auto baseArray = dynamic_cast<ArrayType const*>(_sourceType.baseType()))
				copyArrayToMemory(*baseArray, _padToWordBoundaries);
			else
				utils.storeInMemoryDynamic(*_sourceType.baseType());
			// increment storage_data_offset and byte offset
			if (haveByteOffset)
				incrementByteOffset(storageBytes, 2, 3);
			else
			{
				m_context << Instruction::SWAP1;
				m_context << storageSize << Instruction::ADD;
				m_context << Instruction::SWAP1;
			}
		}
		// check for loop condition
		m_context << Instruction::DUP1 << dupInstruction(haveByteOffset ? 5 : 4);
		m_context << Instruction::GT;
		m_context.appendConditionalJumpTo(loopStart);
		// stack here: memory_end_offset storage_data_offset [storage_byte_offset] memory_offset
		if (haveByteOffset)
			m_context << Instruction::SWAP1 << Instruction::POP;
		if (_padToWordBoundaries && baseSize % 32 != 0)
		{
			// memory_end_offset - start is the actual length (we want to compute the ceil of).
			// memory_offset - start is its next multiple of 32, but it might be off by 32.
			// so we compute: memory_end_offset += (memory_offset - memory_end_offest) & 31
			m_context << Instruction::DUP3 << Instruction::SWAP1 << Instruction::SUB;
			m_context << u256(31) << Instruction::AND;
			m_context << Instruction::DUP3 << Instruction::ADD;
			m_context << Instruction::SWAP2;
		}
		m_context << loopEnd << Instruction::POP << Instruction::POP;
	}
}

void ArrayUtils::clearArray(ArrayType const& _typeIn) const
{
	TypePointer type = &_typeIn;
	m_context.callLowLevelFunction(
		"$clearArray_" + _typeIn.identifier(),
		2,
		0,
		[type](CompilerContext& _context)
		{
			ArrayType const& _type = dynamic_cast<ArrayType const&>(*type);
			unsigned stackHeightStart = _context.stackHeight();
			solAssert(_type.location() == DataLocation::Storage, "");
			if (_type.baseType()->storageBytes() < 32)
			{
				solAssert(_type.baseType()->isValueType(), "Invalid storage size for non-value type.");
				solAssert(_type.baseType()->storageSize() <= 1, "Invalid storage size for type.");
			}
			if (_type.baseType()->isValueType())
				solAssert(_type.baseType()->storageSize() <= 1, "Invalid size for value type.");

			_context << Instruction::POP; // remove byte offset
			if (_type.isDynamicallySized())
				ArrayUtils(_context).clearDynamicArray(_type);
			else if (_type.length() == 0 || _type.baseType()->category() == Type::Category::Mapping)
				_context << Instruction::POP;
			else if (_type.baseType()->isValueType() && _type.storageSize() <= 5)
			{
				// unroll loop for small arrays @todo choose a good value
				// Note that we loop over storage slots here, not elements.
				for (unsigned i = 1; i < _type.storageSize(); ++i)
					_context
						<< u256(0) << Instruction::DUP2 << Instruction::SSTORE
						<< u256(1) << Instruction::ADD;
				_context << u256(0) << Instruction::SWAP1 << Instruction::SSTORE;
			}
			else if (!_type.baseType()->isValueType() && _type.length() <= 4)
			{
				// unroll loop for small arrays @todo choose a good value
				solAssert(_type.baseType()->storageBytes() >= 32, "Invalid storage size.");
				for (unsigned i = 1; i < _type.length(); ++i)
				{
					_context << u256(0);
					StorageItem(_context, *_type.baseType()).setToZero(SourceLocation(), false);
					_context
						<< Instruction::POP
						<< u256(_type.baseType()->storageSize()) << Instruction::ADD;
				}
				_context << u256(0);
				StorageItem(_context, *_type.baseType()).setToZero(SourceLocation(), true);
			}
			else
			{
				_context << Instruction::DUP1 << _type.length();
				ArrayUtils(_context).convertLengthToSize(_type);
				_context << Instruction::ADD << Instruction::SWAP1;
				if (_type.baseType()->storageBytes() < 32)
					ArrayUtils(_context).clearStorageLoop(TypeProvider::uint256());
				else
					ArrayUtils(_context).clearStorageLoop(_type.baseType());
				_context << Instruction::POP;
			}
			solAssert(_context.stackHeight() == stackHeightStart - 2, "");
		}
	);
}

void ArrayUtils::clearDynamicArray(ArrayType const& _type) const
{
	solAssert(_type.location() == DataLocation::Storage, "");
	solAssert(_type.isDynamicallySized(), "");

	// fetch length
	retrieveLength(_type);
	// set length to zero
	m_context << u256(0) << Instruction::DUP3 << Instruction::SSTORE;
	// Special case: short byte arrays are stored togeher with their length
	eth::AssemblyItem endTag = m_context.newTag();
	if (_type.isByteArray())
	{
		// stack: ref old_length
		m_context << Instruction::DUP1 << u256(31) << Instruction::LT;
		eth::AssemblyItem longByteArray = m_context.appendConditionalJump();
		m_context << Instruction::POP;
		m_context.appendJumpTo(endTag);
		m_context.adjustStackOffset(1); // needed because of jump
		m_context << longByteArray;
	}
	// stack: ref old_length
	convertLengthToSize(_type);
	// compute data positions
	m_context << Instruction::SWAP1;
	CompilerUtils(m_context).computeHashStatic();
	// stack: len data_pos
	m_context << Instruction::SWAP1 << Instruction::DUP2 << Instruction::ADD
		<< Instruction::SWAP1;
	// stack: data_pos_end data_pos
	if (_type.storageStride() < 32)
		clearStorageLoop(TypeProvider::uint256());
	else
		clearStorageLoop(_type.baseType());
	// cleanup
	m_context << endTag;
	m_context << Instruction::POP;
}

void ArrayUtils::resizeDynamicArray(ArrayType const& _typeIn) const
{
	TypePointer type = &_typeIn;
	m_context.callLowLevelFunction(
		"$resizeDynamicArray_" + _typeIn.identifier(),
		2,
		0,
		[type](CompilerContext& _context)
		{
			ArrayType const& _type = dynamic_cast<ArrayType const&>(*type);
			solAssert(_type.location() == DataLocation::Storage, "");
			solAssert(_type.isDynamicallySized(), "");
			if (!_type.isByteArray() && _type.baseType()->storageBytes() < 32)
				solAssert(_type.baseType()->isValueType(), "Invalid storage size for non-value type.");

			unsigned stackHeightStart = _context.stackHeight();
			eth::AssemblyItem resizeEnd = _context.newTag();

			// stack: ref new_length
			// fetch old length
			ArrayUtils(_context).retrieveLength(_type, 1);
			// stack: ref new_length old_length
			solAssert(_context.stackHeight() - stackHeightStart == 3 - 2, "2");

			// Special case for short byte arrays, they are stored together with their length
			if (_type.isByteArray())
			{
				eth::AssemblyItem regularPath = _context.newTag();
				// We start by a large case-distinction about the old and new length of the byte array.

				_context << Instruction::DUP3 << Instruction::SLOAD;
				// stack: ref new_length current_length ref_value

				solAssert(_context.stackHeight() - stackHeightStart == 4 - 2, "3");
				_context << Instruction::DUP2 << u256(31) << Instruction::LT;
				eth::AssemblyItem currentIsLong = _context.appendConditionalJump();
				_context << Instruction::DUP3 << u256(31) << Instruction::LT;
				eth::AssemblyItem newIsLong = _context.appendConditionalJump();

				// Here: short -> short

				// Compute 1 << (256 - 8 * new_size)
				eth::AssemblyItem shortToShort = _context.newTag();
				_context << shortToShort;
				_context << Instruction::DUP3 << u256(8) << Instruction::MUL;
				_context << u256(0x100) << Instruction::SUB;
				_context << u256(2) << Instruction::EXP;
				// Divide and multiply by that value, clearing bits.
				_context << Instruction::DUP1 << Instruction::SWAP2;
				_context << Instruction::DIV << Instruction::MUL;
				// Insert 2*length.
				_context << Instruction::DUP3 << Instruction::DUP1 << Instruction::ADD;
				_context << Instruction::OR;
				// Store.
				_context << Instruction::DUP4 << Instruction::SSTORE;
				solAssert(_context.stackHeight() - stackHeightStart == 3 - 2, "3");
				_context.appendJumpTo(resizeEnd);

				_context.adjustStackOffset(1); // we have to do that because of the jumps
				// Here: short -> long

				_context << newIsLong;
				// stack: ref new_length current_length ref_value
				solAssert(_context.stackHeight() - stackHeightStart == 4 - 2, "3");
				// Zero out lower-order byte.
				_context << u256(0xff) << Instruction::NOT << Instruction::AND;
				// Store at data location.
				_context << Instruction::DUP4;
				CompilerUtils(_context).computeHashStatic();
				_context << Instruction::SSTORE;
				// stack: ref new_length current_length
				// Store new length: Compule 2*length + 1 and store it.
				_context << Instruction::DUP2 << Instruction::DUP1 << Instruction::ADD;
				_context << u256(1) << Instruction::ADD;
				// stack: ref new_length current_length 2*new_length+1
				_context << Instruction::DUP4 << Instruction::SSTORE;
				solAssert(_context.stackHeight() - stackHeightStart == 3 - 2, "3");
				_context.appendJumpTo(resizeEnd);

				_context.adjustStackOffset(1); // we have to do that because of the jumps

				_context << currentIsLong;
				_context << Instruction::DUP3 << u256(31) << Instruction::LT;
				_context.appendConditionalJumpTo(regularPath);

				// Here: long -> short
				// Read the first word of the data and store it on the stack. Clear the data location and
				// then jump to the short -> short case.

				// stack: ref new_length current_length ref_value
				solAssert(_context.stackHeight() - stackHeightStart == 4 - 2, "3");
				_context << Instruction::POP << Instruction::DUP3;
				CompilerUtils(_context).computeHashStatic();
				_context << Instruction::DUP1 << Instruction::SLOAD << Instruction::SWAP1;
				// stack: ref new_length current_length first_word data_location
				_context << Instruction::DUP3;
				ArrayUtils(_context).convertLengthToSize(_type);
				_context << Instruction::DUP2 << Instruction::ADD << Instruction::SWAP1;
				// stack: ref new_length current_length first_word data_location_end data_location
				ArrayUtils(_context).clearStorageLoop(TypeProvider::uint256());
				_context << Instruction::POP;
				// stack: ref new_length current_length first_word
				solAssert(_context.stackHeight() - stackHeightStart == 4 - 2, "3");
				_context.appendJumpTo(shortToShort);

				_context << regularPath;
				// stack: ref new_length current_length ref_value
				_context << Instruction::POP;
			}

			// Change of length for a regular array (i.e. length at location, data at KECCAK256(location)).
			// stack: ref new_length old_length
			// store new length
			_context << Instruction::DUP2;
			if (_type.isByteArray())
				// For a "long" byte array, store length as 2*length+1
				_context << Instruction::DUP1 << Instruction::ADD << u256(1) << Instruction::ADD;
			_context << Instruction::DUP4 << Instruction::SSTORE;
			// skip if size is not reduced
			_context << Instruction::DUP2 << Instruction::DUP2
				<< Instruction::GT << Instruction::ISZERO;
			_context.appendConditionalJumpTo(resizeEnd);

			// size reduced, clear the end of the array
			// stack: ref new_length old_length
			ArrayUtils(_context).convertLengthToSize(_type);
			_context << Instruction::DUP2;
			ArrayUtils(_context).convertLengthToSize(_type);
			// stack: ref new_length old_size new_size
			// compute data positions
			_context << Instruction::DUP4;
			CompilerUtils(_context).computeHashStatic();
			// stack: ref new_length old_size new_size data_pos
			_context << Instruction::SWAP2 << Instruction::DUP3 << Instruction::ADD;
			// stack: ref new_length data_pos new_size delete_end
			_context << Instruction::SWAP2 << Instruction::ADD;
			// stack: ref new_length delete_end delete_start
			if (_type.storageStride() < 32)
				ArrayUtils(_context).clearStorageLoop(TypeProvider::uint256());
			else
				ArrayUtils(_context).clearStorageLoop(_type.baseType());

			_context << resizeEnd;
			// cleanup
			_context << Instruction::POP << Instruction::POP << Instruction::POP;
			solAssert(_context.stackHeight() == stackHeightStart - 2, "");
		}
	);
}

void ArrayUtils::incrementDynamicArraySize(ArrayType const& _type) const
{
	solAssert(_type.location() == DataLocation::Storage, "");
	solAssert(_type.isDynamicallySized(), "");
	if (!_type.isByteArray() && _type.baseType()->storageBytes() < 32)
		solAssert(_type.baseType()->isValueType(), "Invalid storage size for non-value type.");

	if (_type.isByteArray())
	{
		// We almost always just add 2 (length of byte arrays is shifted left by one)
		// except for the case where we transition from a short byte array
		// to a long byte array, there we have to copy.
		// This happens if the length is exactly 31, which means that the
		// lowest-order byte (we actually use a mask with fewer bits) must
		// be (31*2+0) = 62

		m_context.appendInlineAssembly(R"({
			let data := sload(ref)
			let shifted_length := and(data, 63)
			// We have to copy if length is exactly 31, because that marks
			// the transition between in-place and out-of-place storage.
			switch shifted_length
			case 62
			{
				mstore(0, ref)
				let data_area := keccak256(0, 0x20)
				sstore(data_area, and(data, not(0xff)))
				// New length is 32, encoded as (32 * 2 + 1)
				sstore(ref, 65)
				// Replace ref variable by new length
				ref := 32
			}
			default
			{
				sstore(ref, add(data, 2))
				// Replace ref variable by new length
				if iszero(and(data, 1)) { data := shifted_length }
				ref := add(div(data, 2), 1)
			}
		})", {"ref"});
	}
	else
		m_context.appendInlineAssembly(R"({
			let new_length := add(sload(ref), 1)
			sstore(ref, new_length)
			ref := new_length
		})", {"ref"});
}

void ArrayUtils::popStorageArrayElement(ArrayType const& _type) const
{
	solAssert(_type.location() == DataLocation::Storage, "");
	solAssert(_type.isDynamicallySized(), "");
	if (!_type.isByteArray() && _type.baseType()->storageBytes() < 32)
		solAssert(_type.baseType()->isValueType(), "Invalid storage size for non-value type.");

	if (_type.isByteArray())
	{
		m_context.appendInlineAssembly(R"({
			let slot_value := sload(ref)
			switch and(slot_value, 1)
			case 0 {
				// short byte array
				let length := and(div(slot_value, 2), 0x1f)
				if iszero(length) { invalid() }

				// Zero-out the suffix including the least significant byte.
				let mask := sub(exp(0x100, sub(33, length)), 1)
				length := sub(length, 1)
				slot_value := or(and(not(mask), slot_value), mul(length, 2))
				sstore(ref, slot_value)
			}
			case 1 {
				// long byte array
				mstore(0, ref)
				let length := div(slot_value, 2)
				let slot := keccak256(0, 0x20)
				switch length
				case 32
				{
					let data := sload(slot)
					sstore(slot, 0)
					data := and(data, not(0xff))
					sstore(ref, or(data, 62))
				}
				default
				{
					let offset_inside_slot := and(sub(length, 1), 0x1f)
					slot := add(slot, div(sub(length, 1), 32))
					let data := sload(slot)

					// Zero-out the suffix of the byte array by masking it.
					// ((1<<(8 * (32 - offset))) - 1)
					let mask := sub(exp(0x100, sub(32, offset_inside_slot)), 1)
					data := and(not(mask), data)
					sstore(slot, data)

					// Reduce the length by 1
					slot_value := sub(slot_value, 2)
					sstore(ref, slot_value)
				}
			}
		})", {"ref"});
		m_context << Instruction::POP;
	}
	else
	{
		// stack: ArrayReference
		retrieveLength(_type);
		// stack: ArrayReference oldLength
		m_context << Instruction::DUP1;
		// stack: ArrayReference oldLength oldLength
		m_context << Instruction::ISZERO;
		m_context.appendConditionalInvalid();

		// Stack: ArrayReference oldLength
		m_context << u256(1) << Instruction::SWAP1 << Instruction::SUB;
		// Stack ArrayReference newLength
		m_context << Instruction::DUP2 << Instruction::DUP2;
		// Stack ArrayReference newLength ArrayReference newLength;
		accessIndex(_type, false);
		// Stack: ArrayReference newLength storage_slot byte_offset
		StorageItem(m_context, *_type.baseType()).setToZero(SourceLocation(), true);
		// Stack: ArrayReference newLength
		m_context << Instruction::SWAP1 << Instruction::SSTORE;
	}
}

void ArrayUtils::clearStorageLoop(TypePointer _type) const
{
	m_context.callLowLevelFunction(
		"$clearStorageLoop_" + _type->identifier(),
		2,
		1,
		[_type](CompilerContext& _context)
		{
			unsigned stackHeightStart = _context.stackHeight();
			if (_type->category() == Type::Category::Mapping)
			{
				_context << Instruction::POP;
				return;
			}
			// stack: end_pos pos

			// jump to and return from the loop to allow for duplicate code removal
			eth::AssemblyItem returnTag = _context.pushNewTag();
			_context << Instruction::SWAP2 << Instruction::SWAP1;

			// stack: <return tag> end_pos pos
			eth::AssemblyItem loopStart = _context.appendJumpToNew();
			_context << loopStart;
			// check for loop condition
			_context <<
				Instruction::DUP1 <<
				Instruction::DUP3 <<
				Instruction::GT <<
				Instruction::ISZERO;
			eth::AssemblyItem zeroLoopEnd = _context.newTag();
			_context.appendConditionalJumpTo(zeroLoopEnd);
			// delete
			_context << u256(0);
			StorageItem(_context, *_type).setToZero(SourceLocation(), false);
			_context << Instruction::POP;
			// increment
			_context << _type->storageSize() << Instruction::ADD;
			_context.appendJumpTo(loopStart);
			// cleanup
			_context << zeroLoopEnd;
			_context << Instruction::POP << Instruction::SWAP1;
			// "return"
			_context << Instruction::JUMP;

			_context << returnTag;
			solAssert(_context.stackHeight() == stackHeightStart - 1, "");
		}
	);
}

void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType, bool _pad) const
{
	if (_arrayType.location() == DataLocation::Storage)
	{
		if (_arrayType.baseType()->storageSize() <= 1)
		{
			unsigned baseBytes = _arrayType.baseType()->storageBytes();
			if (baseBytes == 0)
				m_context << Instruction::POP << u256(1);
			else if (baseBytes <= 16)
			{
				unsigned itemsPerSlot = 32 / baseBytes;
				m_context
					<< u256(itemsPerSlot - 1) << Instruction::ADD
					<< u256(itemsPerSlot) << Instruction::SWAP1 << Instruction::DIV;
			}
		}
		else
			m_context << _arrayType.baseType()->storageSize() << Instruction::MUL;
	}
	else
	{
		if (!_arrayType.isByteArray())
		{
			if (_arrayType.location() == DataLocation::Memory)
				m_context << _arrayType.baseType()->memoryHeadSize();
			else
				m_context << _arrayType.baseType()->calldataEncodedSize();
			m_context << Instruction::MUL;
		}
		else if (_pad)
			m_context << u256(31) << Instruction::ADD
				<< u256(32) << Instruction::DUP1
				<< Instruction::SWAP2 << Instruction::DIV << Instruction::MUL;
	}
}

void ArrayUtils::retrieveLength(ArrayType const& _arrayType, unsigned _stackDepth) const
{
	if (!_arrayType.isDynamicallySized())
		m_context << _arrayType.length();
	else
	{
		m_context << dupInstruction(1 + _stackDepth);
		switch (_arrayType.location())
		{
		case DataLocation::CallData:
			// length is stored on the stack
			break;
		case DataLocation::Memory:
			m_context << Instruction::MLOAD;
			break;
		case DataLocation::Storage:
			m_context << Instruction::SLOAD;
			if (_arrayType.isByteArray())
			{
				// Retrieve length both for in-place strings and off-place strings:
				// Computes (x & (0x100 * (ISZERO (x & 1)) - 1)) / 2
				// i.e. for short strings (x & 1 == 0) it does (x & 0xff) / 2 and for long strings it
				// computes (x & (-1)) / 2, which is equivalent to just x / 2.
				m_context << u256(1) << Instruction::DUP2 << u256(1) << Instruction::AND;
				m_context << Instruction::ISZERO << u256(0x100) << Instruction::MUL;
				m_context << Instruction::SUB << Instruction::AND;
				m_context << u256(2) << Instruction::SWAP1 << Instruction::DIV;
			}
			break;
		}
	}
}

void ArrayUtils::accessIndex(ArrayType const& _arrayType, bool _doBoundsCheck, bool _keepReference) const
{
	/// Stack: reference [length] index
	DataLocation location = _arrayType.location();

	if (_doBoundsCheck)
	{
		// retrieve length
		ArrayUtils::retrieveLength(_arrayType, 1);
		// Stack: ref [length] index length
		// check out-of-bounds access
		m_context << Instruction::DUP2 << Instruction::LT << Instruction::ISZERO;
		// out-of-bounds access throws exception
		m_context.appendConditionalInvalid();
	}
	if (location == DataLocation::CallData && _arrayType.isDynamicallySized())
		// remove length if present
		m_context << Instruction::SWAP1 << Instruction::POP;

	// stack: <base_ref> <index>
	switch (location)
	{
	case DataLocation::Memory:
	case DataLocation::CallData:
		if (!_arrayType.isByteArray())
		{
			if (location == DataLocation::CallData)
			{
				if (_arrayType.baseType()->isDynamicallyEncoded())
					m_context << u256(0x20);
				else
					m_context << _arrayType.baseType()->calldataEncodedSize();
			}
			else
				m_context << u256(_arrayType.memoryHeadSize());
			m_context << Instruction::MUL;
		}
		// stack: <base_ref> <index * size>

		if (location == DataLocation::Memory && _arrayType.isDynamicallySized())
			m_context << u256(32) << Instruction::ADD;

		if (_keepReference)
			m_context << Instruction::DUP2;

		m_context << Instruction::ADD;
		break;
	case DataLocation::Storage:
	{
		if (_keepReference)
			m_context << Instruction::DUP2;
		else
			m_context << Instruction::SWAP1;
		// stack: [<base_ref>] <index> <base_ref>

		eth::AssemblyItem endTag = m_context.newTag();
		if (_arrayType.isByteArray())
		{
			// Special case of short byte arrays.
			m_context << Instruction::SWAP1;
			m_context << Instruction::DUP2 << Instruction::SLOAD;
			m_context << u256(1) << Instruction::AND << Instruction::ISZERO;
			// No action needed for short byte arrays.
			m_context.appendConditionalJumpTo(endTag);
			m_context << Instruction::SWAP1;
		}
		if (_arrayType.isDynamicallySized())
			CompilerUtils(m_context).computeHashStatic();
		m_context << Instruction::SWAP1;
		if (_arrayType.baseType()->storageBytes() <= 16)
		{
			// stack: <data_ref> <index>
			// goal:
			// <ref> <byte_number> = <base_ref + index / itemsPerSlot> <(index % itemsPerSlot) * byteSize>
			unsigned byteSize = _arrayType.baseType()->storageBytes();
			solAssert(byteSize != 0, "");
			unsigned itemsPerSlot = 32 / byteSize;
			m_context << u256(itemsPerSlot) << Instruction::SWAP2;
			// stack: itemsPerSlot index data_ref
			m_context
				<< Instruction::DUP3 << Instruction::DUP3
				<< Instruction::DIV << Instruction::ADD
			// stack: itemsPerSlot index (data_ref + index / itemsPerSlot)
				<< Instruction::SWAP2 << Instruction::SWAP1
				<< Instruction::MOD;
			if (byteSize != 1)
				m_context << u256(byteSize) << Instruction::MUL;
		}
		else
		{
			if (_arrayType.baseType()->storageSize() != 1)
				m_context << _arrayType.baseType()->storageSize() << Instruction::MUL;
			m_context << Instruction::ADD << u256(0);
		}
		m_context << endTag;
		break;
	}
	}
}

void ArrayUtils::incrementByteOffset(unsigned _byteSize, unsigned _byteOffsetPosition, unsigned _storageOffsetPosition) const
{
	solAssert(_byteSize < 32, "");
	solAssert(_byteSize != 0, "");
	// We do the following, but avoiding jumps:
	// byteOffset += byteSize
	// if (byteOffset + byteSize > 32)
	// {
	//     storageOffset++;
	//     byteOffset = 0;
	// }
	if (_byteOffsetPosition > 1)
		m_context << swapInstruction(_byteOffsetPosition - 1);
	m_context << u256(_byteSize) << Instruction::ADD;
	if (_byteOffsetPosition > 1)
		m_context << swapInstruction(_byteOffsetPosition - 1);
	// compute, X := (byteOffset + byteSize - 1) / 32, should be 1 iff byteOffset + bytesize > 32
	m_context
		<< u256(32) << dupInstruction(1 + _byteOffsetPosition) << u256(_byteSize - 1)
		<< Instruction::ADD << Instruction::DIV;
	// increment storage offset if X == 1 (just add X to it)
	// stack: X
	m_context
		<< swapInstruction(_storageOffsetPosition) << dupInstruction(_storageOffsetPosition + 1)
		<< Instruction::ADD << swapInstruction(_storageOffsetPosition);
	// stack: X
	// set source_byte_offset to zero if X == 1 (using source_byte_offset *= 1 - X)
	m_context << u256(1) << Instruction::SUB;
	// stack: 1 - X
	if (_byteOffsetPosition == 1)
		m_context << Instruction::MUL;
	else
		m_context
			<< dupInstruction(_byteOffsetPosition + 1) << Instruction::MUL
			<< swapInstruction(_byteOffsetPosition) << Instruction::POP;
}