diff options
| -rw-r--r-- | CompilerUtils.cpp | 213 | ||||
| -rw-r--r-- | CompilerUtils.h | 13 | ||||
| -rw-r--r-- | ExpressionCompiler.cpp | 186 | ||||
| -rw-r--r-- | ExpressionCompiler.h | 2 |
4 files changed, 238 insertions, 176 deletions
diff --git a/CompilerUtils.cpp b/CompilerUtils.cpp index c38149c1..192d66d5 100644 --- a/CompilerUtils.cpp +++ b/CompilerUtils.cpp @@ -64,6 +64,7 @@ unsigned CompilerUtils::loadFromMemory(unsigned _offset, unsigned _bytes, bool _ unsigned CompilerUtils::storeInMemory(unsigned _offset, Type const& _type, bool _padToWordBoundaries) { + solAssert(_type.getCategory() != Type::Category::ByteArray, "Unable to statically store dynamic type."); unsigned numBytes = prepareMemoryStore(_type, _padToWordBoundaries); if (numBytes > 0) m_context << u256(_offset) << eth::Instruction::MSTORE; @@ -72,11 +73,47 @@ unsigned CompilerUtils::storeInMemory(unsigned _offset, Type const& _type, bool void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBoundaries) { - unsigned numBytes = prepareMemoryStore(_type, _padToWordBoundaries); - if (numBytes > 0) + if (_type.getCategory() == Type::Category::ByteArray) { - m_context << eth::Instruction::DUP2 << eth::Instruction::MSTORE; - m_context << u256(numBytes) << eth::Instruction::ADD; + auto const& type = dynamic_cast<ByteArrayType const&>(_type); + solAssert(type.getLocation() == ByteArrayType::Location::Storage, "Non-storage byte arrays not yet implemented."); + + m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD; + // stack here: memory_offset storage_offset length_bytes + // jump to end if length is zero + m_context << eth::Instruction::DUP1 << eth::Instruction::ISZERO; + eth::AssemblyItem loopEnd = m_context.newTag(); + m_context.appendConditionalJumpTo(loopEnd); + // compute memory end offset + m_context << eth::Instruction::DUP3 << eth::Instruction::ADD << eth::Instruction::SWAP2; + // actual array data is stored at SHA3(storage_offset) + m_context << eth::Instruction::SWAP1; + CompilerUtils(m_context).computeHashStatic(); + m_context << eth::Instruction::SWAP1; + + // stack here: memory_end_offset storage_data_offset memory_offset + eth::AssemblyItem loopStart = m_context.newTag(); + m_context << loopStart + // load and store + << eth::Instruction::DUP2 << eth::Instruction::SLOAD + << eth::Instruction::DUP2 << eth::Instruction::MSTORE + // increment storage_data_offset by 1 + << eth::Instruction::SWAP1 << u256(1) << eth::Instruction::ADD + // increment memory offset by 32 + << eth::Instruction::SWAP1 << u256(32) << eth::Instruction::ADD + // check for loop condition + << eth::Instruction::DUP1 << eth::Instruction::DUP4 << eth::Instruction::GT; + m_context.appendConditionalJumpTo(loopStart); + m_context << loopEnd << eth::Instruction::POP << eth::Instruction::POP; + } + else + { + unsigned numBytes = prepareMemoryStore(_type, _padToWordBoundaries); + if (numBytes > 0) + { + m_context << eth::Instruction::DUP2 << eth::Instruction::MSTORE; + m_context << u256(numBytes) << eth::Instruction::ADD; + } } } @@ -122,7 +159,153 @@ void CompilerUtils::computeHashStatic(Type const& _type, bool _padToWordBoundari m_context << u256(length) << u256(0) << eth::Instruction::SHA3; } -unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWordBoundaries) +void CompilerUtils::copyByteArrayToStorage(ByteArrayType const& _targetType, + ByteArrayType const& _sourceType) const +{ + // stack layout: [source_ref] target_ref (top) + // need to leave target_ref on the stack at the end + solAssert(_targetType.getLocation() == ByteArrayType::Location::Storage, ""); + + switch (_sourceType.getLocation()) + { + case ByteArrayType::Location::CallData: + { + // @todo this does not take length into account. It also assumes that after "CALLDATALENGTH" we only have zeros. + // fetch old length and convert to words + m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD; + m_context << u256(31) << eth::Instruction::ADD + << u256(32) << eth::Instruction::SWAP1 << eth::Instruction::DIV; + // stack here: target_ref target_length_words + // actual array data is stored at SHA3(storage_offset) + m_context << eth::Instruction::DUP2; + CompilerUtils(m_context).computeHashStatic(); + // compute target_data_end + m_context << eth::Instruction::DUP1 << eth::Instruction::SWAP2 << eth::Instruction::ADD + << eth::Instruction::SWAP1; + // stack here: target_ref target_data_end target_data_ref + // store length (in bytes) + if (_sourceType.getOffset() == 0) + m_context << eth::Instruction::CALLDATASIZE; + else + m_context << _sourceType.getOffset() << eth::Instruction::CALLDATASIZE << eth::Instruction::SUB; + m_context << eth::Instruction::DUP1 << eth::Instruction::DUP5 << eth::Instruction::SSTORE; + // jump to end if length is zero + m_context << eth::Instruction::ISZERO; + eth::AssemblyItem copyLoopEnd = m_context.newTag(); + m_context.appendConditionalJumpTo(copyLoopEnd); + + m_context << _sourceType.getOffset(); + // stack now: target_ref target_data_end target_data_ref calldata_offset + eth::AssemblyItem copyLoopStart = m_context.newTag(); + m_context << copyLoopStart + // copy from calldata and store + << eth::Instruction::DUP1 << eth::Instruction::CALLDATALOAD + << eth::Instruction::DUP3 << eth::Instruction::SSTORE + // increment target_data_ref by 1 + << eth::Instruction::SWAP1 << u256(1) << eth::Instruction::ADD + // increment calldata_offset by 32 + << eth::Instruction::SWAP1 << u256(32) << eth::Instruction::ADD + // check for loop condition + << eth::Instruction::DUP1 << eth::Instruction::CALLDATASIZE << eth::Instruction::GT; + m_context.appendConditionalJumpTo(copyLoopStart); + m_context << eth::Instruction::POP; + m_context << copyLoopEnd; + + // now clear leftover bytes of the old value + // stack now: target_ref target_data_end target_data_ref + clearStorageLoop(); + + m_context << eth::Instruction::POP; + break; + } + case ByteArrayType::Location::Storage: + { + // this copies source to target and also clears target if it was larger + + // stack: source_ref target_ref + // store target_ref + m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2; + // 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; + // compute hashes (data positions) + m_context << eth::Instruction::SWAP2; + 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 + // @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 + eth::AssemblyItem copyLoopStart = m_context.newTag(); + m_context << copyLoopStart; + // check for loop condition + m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3 + << eth::Instruction::GT << eth::Instruction::ISZERO; + 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; + // increment + m_context << u256(1) << 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 + // 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 + 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(); + m_context << eth::Instruction::POP; + break; + } + default: + solAssert(false, "Given byte array location not implemented."); + } +} + +void CompilerUtils::clearByteArray(ByteArrayType const& _type) const +{ + solAssert(_type.getLocation() == ByteArrayType::Location::Storage, ""); + + // fetch length + m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD; + // set length to zero + m_context << u256(0) << eth::Instruction::DUP3 << eth::Instruction::SSTORE; + // convert length from bytes to storage slots + m_context << u256(31) << eth::Instruction::ADD + << u256(32) << eth::Instruction::SWAP1 << eth::Instruction::DIV; + // compute data positions + m_context << eth::Instruction::SWAP1; + CompilerUtils(m_context).computeHashStatic(); + // stack: len data_pos + m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2 << eth::Instruction::ADD + << eth::Instruction::SWAP1; + clearStorageLoop(); + // cleanup + m_context << eth::Instruction::POP; +} + +unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWordBoundaries) const { unsigned _encodedSize = _type.getCalldataEncodedSize(); unsigned numBytes = _padToWordBoundaries ? getPaddedSize(_encodedSize) : _encodedSize; @@ -139,5 +322,25 @@ unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWordBou return numBytes; } +void CompilerUtils::clearStorageLoop() const +{ + // stack: end_pos pos + eth::AssemblyItem loopStart = m_context.newTag(); + m_context << loopStart; + // check for loop condition + m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3 + << eth::Instruction::GT << eth::Instruction::ISZERO; + eth::AssemblyItem zeroLoopEnd = m_context.newTag(); + m_context.appendConditionalJumpTo(zeroLoopEnd); + // zero out + m_context << u256(0) << eth::Instruction::DUP2 << eth::Instruction::SSTORE; + // increment + m_context << u256(1) << eth::Instruction::ADD; + m_context.appendJumpTo(loopStart); + // cleanup + m_context << zeroLoopEnd; + m_context << eth::Instruction::POP; +} + } } diff --git a/CompilerUtils.h b/CompilerUtils.h index 49375047..7ac3cc29 100644 --- a/CompilerUtils.h +++ b/CompilerUtils.h @@ -75,12 +75,23 @@ public: /// @note Only works for types of fixed size. void computeHashStatic(Type const& _type = IntegerType(256), bool _padToWordBoundaries = false); + /// Copies a byte array to a byte array in storage, where the target is assumed to be on the + /// to top of the stay. Leaves a reference to the target on the stack. + void copyByteArrayToStorage(ByteArrayType const& _targetType, ByteArrayType const& _sourceType) const; + /// Clears the length and data elements of the byte array referenced on the stack. + /// Removes the reference from the stack. + void clearByteArray(ByteArrayType const& _type) const; + /// Bytes we need to the start of call data. /// - The size in bytes of the function (hash) identifier. static const unsigned int dataStartOffset; private: - unsigned prepareMemoryStore(Type const& _type, bool _padToWordBoundaries); + unsigned prepareMemoryStore(Type const& _type, bool _padToWordBoundaries) const; + /// Appends a loop that clears all storage between the storage reference at the stack top + /// and the one below it (excluding). + /// Will leave the single value of the end pointer on the stack. + void clearStorageLoop() const; CompilerContext& m_context; }; diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp index a05d71e6..b373bfbc 100644 --- a/ExpressionCompiler.cpp +++ b/ExpressionCompiler.cpp @@ -105,7 +105,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation) break; case Token::Delete: // delete solAssert(m_currentLValue.isValid(), "LValue not retrieved."); - m_currentLValue.setToZero(_unaryOperation); + m_currentLValue.setToZero(_unaryOperation, *_unaryOperation.getSubExpression().getType()); m_currentLValue.reset(); break; case Token::Inc: // ++ (pre- or postfix) @@ -886,43 +886,7 @@ void ExpressionCompiler::appendArgumentsCopyToMemory(vector<ASTPointer<Expressio void ExpressionCompiler::appendTypeMoveToMemory(Type const& _type, bool _padToWordBoundaries) { - // @TODO move this to CompilerUtils! - - if (_type.getCategory() == Type::Category::ByteArray) - { - auto const& type = dynamic_cast<ByteArrayType const&>(_type); - solAssert(type.getLocation() == ByteArrayType::Location::Storage, "Non-storage byte arrays not yet implemented."); - - m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD; - // stack here: memory_offset storage_offset length_bytes - // jump to end if length is zero - m_context << eth::Instruction::DUP1 << eth::Instruction::ISZERO; - eth::AssemblyItem loopEnd = m_context.newTag(); - m_context.appendConditionalJumpTo(loopEnd); - // compute memory end offset - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD << eth::Instruction::SWAP2; - // actual array data is stored at SHA3(storage_offset) - m_context << eth::Instruction::SWAP1; - CompilerUtils(m_context).computeHashStatic(); - m_context << eth::Instruction::SWAP1; - - // stack here: memory_end_offset storage_data_offset memory_offset - eth::AssemblyItem loopStart = m_context.newTag(); - m_context << loopStart - // load and store - << eth::Instruction::DUP2 << eth::Instruction::SLOAD - << eth::Instruction::DUP2 << eth::Instruction::MSTORE - // increment storage_data_offset by 1 - << eth::Instruction::SWAP1 << u256(1) << eth::Instruction::ADD - // increment memory offset by 32 - << eth::Instruction::SWAP1 << u256(32) << eth::Instruction::ADD - // check for loop condition - << eth::Instruction::DUP1 << eth::Instruction::DUP4 << eth::Instruction::GT; - m_context.appendConditionalJumpTo(loopStart); - m_context << loopEnd << eth::Instruction::POP << eth::Instruction::POP; - } - else - CompilerUtils(m_context).storeInMemoryDynamic(_type, _padToWordBoundaries); + CompilerUtils(m_context).storeInMemoryDynamic(_type, _padToWordBoundaries); } void ExpressionCompiler::appendExpressionCopyToMemory(Type const& _expectedType, Expression const& _expression) @@ -1097,8 +1061,9 @@ void ExpressionCompiler::LValue::storeValue(Expression const& _expression, Type solAssert(!_move, "Move assign for non-value types not implemented."); solAssert(_sourceType.getCategory() == _expression.getType()->getCategory(), ""); if (_expression.getType()->getCategory() == Type::Category::ByteArray) - copyByteArrayToStorage(dynamic_cast<ByteArrayType const&>(*_expression.getType()), - dynamic_cast<ByteArrayType const&>(_sourceType)); + CompilerUtils(*m_context).copyByteArrayToStorage( + dynamic_cast<ByteArrayType const&>(*_expression.getType()), + dynamic_cast<ByteArrayType const&>(_sourceType)); else if (_expression.getType()->getCategory() == Type::Category::Struct) { //@todo @@ -1122,7 +1087,7 @@ void ExpressionCompiler::LValue::storeValue(Expression const& _expression, Type } } -void ExpressionCompiler::LValue::setToZero(Expression const& _expression) const +void ExpressionCompiler::LValue::setToZero(Expression const& _expression, Type const& _type) const { switch (m_type) { @@ -1139,20 +1104,21 @@ void ExpressionCompiler::LValue::setToZero(Expression const& _expression) const break; } case LValueType::Storage: - if (m_size == 0) - *m_context << eth::Instruction::POP; - for (unsigned i = 0; i < m_size; ++i) + if (_type.getCategory() == Type::Category::ByteArray) + CompilerUtils(*m_context).clearByteArray(dynamic_cast<ByteArrayType const&>(_type)); + else { - if (i + 1 >= m_size) - *m_context << u256(0) << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; - else - *m_context << u256(0) << eth::Instruction::DUP2 << eth::Instruction::SSTORE - << u256(1) << eth::Instruction::ADD; + if (m_size == 0) + *m_context << eth::Instruction::POP; + for (unsigned i = 0; i < m_size; ++i) + if (i + 1 >= m_size) + *m_context << u256(0) << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + else + *m_context << u256(0) << eth::Instruction::DUP2 << eth::Instruction::SSTORE + << u256(1) << eth::Instruction::ADD; } break; case LValueType::Memory: - if (!_expression.getType()->isValueType()) - break; // no distinction between value and reference for non-value types BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_expression.getLocation()) << errinfo_comment("Location type not yet implemented.")); break; @@ -1161,7 +1127,6 @@ void ExpressionCompiler::LValue::setToZero(Expression const& _expression) const << errinfo_comment("Unsupported location type.")); break; } - } void ExpressionCompiler::LValue::retrieveValueIfLValueNotRequested(Expression const& _expression) @@ -1198,123 +1163,6 @@ void ExpressionCompiler::LValue::fromIdentifier(Identifier const& _identifier, D << errinfo_comment("Identifier type not supported or identifier not found.")); } -void ExpressionCompiler::LValue::copyByteArrayToStorage(ByteArrayType const& _targetType, - ByteArrayType const& _sourceType) const -{ - // stack layout: [source_ref] target_ref (head) - // need to leave target_ref on the stack at the end - solAssert(m_type == LValueType::Storage, ""); - solAssert(_targetType.getLocation() == ByteArrayType::Location::Storage, ""); - - // @TODO move this to CompilerUtils! - - switch (_sourceType.getLocation()) - { - case ByteArrayType::Location::CallData: - { - // @todo this does not take length into account. It also assumes that after "CALLDATALENGTH" we only have zeros. - // add some useful constants - *m_context << u256(32) << u256(1); - // stack here: target_ref 32 1 - // store length (in bytes) - if (_sourceType.getOffset() == 0) - *m_context << eth::Instruction::CALLDATASIZE; - else - *m_context << _sourceType.getOffset() << eth::Instruction::CALLDATASIZE << eth::Instruction::SUB; - *m_context << eth::Instruction::DUP1 << eth::Instruction::DUP5 << eth::Instruction::SSTORE; - // jump to end if length is zero - *m_context << eth::Instruction::ISZERO; - eth::AssemblyItem loopEnd = m_context->newTag(); - m_context->appendConditionalJumpTo(loopEnd); - // actual array data is stored at SHA3(storage_offset) - *m_context << eth::Instruction::DUP3; - CompilerUtils(*m_context).computeHashStatic(); - - *m_context << _sourceType.getOffset(); - // stack now: target_ref 32 1 target_data_ref calldata_offset - eth::AssemblyItem loopStart = m_context->newTag(); - *m_context << loopStart - // copy from calldata and store - << eth::Instruction::DUP1 << eth::Instruction::CALLDATALOAD - << eth::Instruction::DUP3 << eth::Instruction::SSTORE - // increment target_data_ref by 1 - << eth::Instruction::SWAP1 << eth::Instruction::DUP3 << eth::Instruction::ADD - // increment calldata_offset by 32 - << eth::Instruction::SWAP1 << eth::Instruction::DUP4 << eth::Instruction::ADD - // check for loop condition - << eth::Instruction::DUP1 << eth::Instruction::CALLDATASIZE << eth::Instruction::GT; - m_context->appendConditionalJumpTo(loopStart); - *m_context << eth::Instruction::POP << eth::Instruction::POP; - *m_context << loopEnd << eth::Instruction::POP << eth::Instruction::POP; - break; - } - case ByteArrayType::Location::Storage: - { - // this copies source to target and also clears target if it was larger - - // stack: 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_len_bytes target_ref source_ref source_len_bytes - // 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(); - *m_context << eth::Instruction::SWAP1; - CompilerUtils(*m_context).computeHashStatic(); - // stack: 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_len_bytes source_len_bytes target_data_pos source_data_pos target_len source_len - // @todo we might be able to go without a third counter - *m_context << u256(0); - // stack: target_len_bytes source_len_bytes target_data_pos source_data_pos target_len source_len counter - eth::AssemblyItem copyLoopStart = m_context->newTag(); - *m_context << copyLoopStart; - // check for loop condition - *m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3 - << eth::Instruction::GT << eth::Instruction::ISZERO; - 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; - // increment - *m_context << u256(1) << eth::Instruction::ADD; - m_context->appendJumpTo(copyLoopStart); - *m_context << copyLoopEnd; - // zero-out leftovers in target - eth::AssemblyItem zeroLoopStart = m_context->newTag(); - *m_context << zeroLoopStart; - // check for loop condition - *m_context << eth::Instruction::DUP1 << eth::Instruction::DUP4 - << eth::Instruction::GT << eth::Instruction::ISZERO; - eth::AssemblyItem zeroLoopEnd = m_context->newTag(); - m_context->appendConditionalJumpTo(zeroLoopEnd); - // zero out - *m_context << u256(0) - << eth::Instruction::DUP6 << eth::Instruction::DUP3 << eth::Instruction::ADD - << eth::Instruction::SSTORE; - // increment - *m_context << u256(1) << eth::Instruction::ADD; - m_context->appendJumpTo(zeroLoopStart); - // cleanup - *m_context << zeroLoopEnd; - *m_context << eth::Instruction::POP << eth::Instruction::POP << eth::Instruction::POP - << eth::Instruction::POP << eth::Instruction::POP << eth::Instruction::POP; - break; - } - default: - solAssert(false, "Given byte array location not implemented."); - } -} } } diff --git a/ExpressionCompiler.h b/ExpressionCompiler.h index dd26881f..e0cc75ce 100644 --- a/ExpressionCompiler.h +++ b/ExpressionCompiler.h @@ -149,7 +149,7 @@ private: void storeValue(Expression const& _expression, Type const& _sourceType, bool _move = false) const; /// Stores zero in the lvalue. /// @a _expression is the current expression, used for error reporting. - void setToZero(Expression const& _expression) const; + void setToZero(Expression const& _expression, Type const& _type) const; /// Convenience function to convert the stored reference to a value and reset type to NONE if /// the reference was not requested by @a _expression. void retrieveValueIfLValueNotRequested(Expression const& _expression); |