Christian
10 years ago
6 changed files with 555 additions and 534 deletions
@ -0,0 +1,220 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2015 |
|||
* LValues for use in the expresison compiler. |
|||
*/ |
|||
|
|||
#include <libsolidity/LValue.h> |
|||
#include <libevmcore/Instruction.h> |
|||
#include <libsolidity/Types.h> |
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/CompilerUtils.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace solidity; |
|||
|
|||
|
|||
StackVariable::StackVariable(CompilerContext& _compilerContext, Declaration const& _declaration): |
|||
LValue(_compilerContext, _declaration.getType()), |
|||
m_baseStackOffset(m_context.getBaseStackOffsetOfVariable(_declaration)), |
|||
m_size(m_dataType->getSizeOnStack()) |
|||
{ |
|||
} |
|||
|
|||
void StackVariable::retrieveValue(SourceLocation const& _location, bool _remove) const |
|||
{ |
|||
unsigned stackPos = m_context.baseToCurrentStackOffset(m_baseStackOffset); |
|||
if (stackPos >= 15) //@todo correct this by fetching earlier or moving to memory
|
|||
BOOST_THROW_EXCEPTION(CompilerError() |
|||
<< errinfo_sourceLocation(_location) << errinfo_comment("Stack too deep.")); |
|||
for (unsigned i = 0; i < m_size; ++i) |
|||
m_context << eth::dupInstruction(stackPos + 1); |
|||
} |
|||
|
|||
void StackVariable::storeValue(Type const& _sourceType, SourceLocation const& _location, bool _move) const |
|||
{ |
|||
unsigned stackDiff = m_context.baseToCurrentStackOffset(m_baseStackOffset) - m_size + 1; |
|||
if (stackDiff > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() |
|||
<< errinfo_sourceLocation(_location) << errinfo_comment("Stack too deep.")); |
|||
else if (stackDiff > 0) |
|||
for (unsigned i = 0; i < m_size; ++i) |
|||
m_context << eth::swapInstruction(stackDiff) << eth::Instruction::POP; |
|||
if (!_move) |
|||
retrieveValue(_location); |
|||
} |
|||
|
|||
void StackVariable::setToZero(SourceLocation const& _location) const |
|||
{ |
|||
unsigned stackDiff = m_context.baseToCurrentStackOffset(m_baseStackOffset); |
|||
if (stackDiff > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() |
|||
<< errinfo_sourceLocation(_location) << errinfo_comment("Stack too deep.")); |
|||
solAssert(stackDiff >= m_size - 1, ""); |
|||
for (unsigned i = 0; i < m_size; ++i) |
|||
m_context << u256(0) << eth::swapInstruction(stackDiff + 1 - i) |
|||
<< eth::Instruction::POP; |
|||
} |
|||
|
|||
|
|||
StorageItem::StorageItem(CompilerContext& _compilerContext, Declaration const& _declaration): |
|||
StorageItem(_compilerContext, _declaration.getType()) |
|||
{ |
|||
m_context << m_context.getStorageLocationOfVariable(_declaration); |
|||
} |
|||
|
|||
StorageItem::StorageItem(CompilerContext& _compilerContext, TypePointer const& _type): |
|||
LValue(_compilerContext, _type) |
|||
{ |
|||
if (m_dataType->isValueType()) |
|||
{ |
|||
solAssert(m_dataType->getStorageSize() == m_dataType->getSizeOnStack(), ""); |
|||
solAssert(m_dataType->getStorageSize() <= numeric_limits<unsigned>::max(), |
|||
"The storage size of " + m_dataType->toString() + " should fit in an unsigned"); |
|||
m_size = unsigned(m_dataType->getStorageSize()); |
|||
} |
|||
else |
|||
m_size = 0; // unused
|
|||
} |
|||
|
|||
void StorageItem::retrieveValue(SourceLocation const&, bool _remove) const |
|||
{ |
|||
if (!m_dataType->isValueType()) |
|||
return; // no distinction between value and reference for non-value types
|
|||
if (!_remove) |
|||
m_context << eth::Instruction::DUP1; |
|||
if (m_size == 1) |
|||
m_context << eth::Instruction::SLOAD; |
|||
else |
|||
for (unsigned i = 0; i < m_size; ++i) |
|||
{ |
|||
m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP1; |
|||
if (i + 1 < m_size) |
|||
m_context << u256(1) << eth::Instruction::ADD; |
|||
else |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
} |
|||
|
|||
void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _location, bool _move) const |
|||
{ |
|||
// stack layout: value value ... value target_ref
|
|||
if (m_dataType->isValueType()) |
|||
{ |
|||
if (!_move) // copy values
|
|||
{ |
|||
if (m_size + 1 > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() |
|||
<< errinfo_sourceLocation(_location) << errinfo_comment("Stack too deep.")); |
|||
for (unsigned i = 0; i < m_size; ++i) |
|||
m_context << eth::dupInstruction(m_size + 1) << eth::Instruction::SWAP1; |
|||
} |
|||
if (m_size > 1) // store high index value first
|
|||
m_context << u256(m_size - 1) << eth::Instruction::ADD; |
|||
for (unsigned i = 0; i < m_size; ++i) |
|||
{ |
|||
if (i + 1 >= m_size) |
|||
m_context << eth::Instruction::SSTORE; |
|||
else |
|||
// stack here: value value ... value value (target_ref+offset)
|
|||
m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2 |
|||
<< eth::Instruction::SSTORE |
|||
<< u256(1) << eth::Instruction::SWAP1 << eth::Instruction::SUB; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
solAssert(_sourceType.getCategory() == m_dataType->getCategory(), |
|||
"Wrong type conversation for assignment."); |
|||
if (m_dataType->getCategory() == Type::Category::Array) |
|||
{ |
|||
CompilerUtils(m_context).copyByteArrayToStorage( |
|||
dynamic_cast<ArrayType const&>(*m_dataType), |
|||
dynamic_cast<ArrayType const&>(_sourceType)); |
|||
if (_move) |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
else if (m_dataType->getCategory() == Type::Category::Struct) |
|||
{ |
|||
// stack layout: source_ref target_ref
|
|||
auto const& structType = dynamic_cast<StructType const&>(*m_dataType); |
|||
solAssert(structType == _sourceType, "Struct assignment with conversion."); |
|||
for (auto const& member: structType.getMembers()) |
|||
{ |
|||
// assign each member that is not a mapping
|
|||
TypePointer const& memberType = member.second; |
|||
if (memberType->getCategory() == Type::Category::Mapping) |
|||
continue; |
|||
m_context << structType.getStorageOffsetOfMember(member.first) |
|||
<< eth::Instruction::DUP3 << eth::Instruction::DUP2 << eth::Instruction::ADD; |
|||
// stack: source_ref target_ref member_offset source_member_ref
|
|||
StorageItem(m_context, memberType).retrieveValue(_location, true); |
|||
// stack: source_ref target_ref member_offset source_value...
|
|||
m_context << eth::dupInstruction(2 + memberType->getSizeOnStack()) |
|||
<< eth::dupInstruction(2 + memberType->getSizeOnStack()) << eth::Instruction::ADD; |
|||
// stack: source_ref target_ref member_offset source_value... target_member_ref
|
|||
StorageItem(m_context, memberType).storeValue(*memberType, _location, true); |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
if (_move) |
|||
m_context << eth::Instruction::POP; |
|||
else |
|||
m_context << eth::Instruction::SWAP1; |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
else |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() |
|||
<< errinfo_sourceLocation(_location) << errinfo_comment("Invalid non-value type for assignment.")); |
|||
} |
|||
} |
|||
|
|||
|
|||
void StorageItem::setToZero(SourceLocation const& _location) const |
|||
{ |
|||
if (m_dataType->getCategory() == Type::Category::Array) |
|||
CompilerUtils(m_context).clearByteArray(dynamic_cast<ArrayType const&>(*m_dataType)); |
|||
else if (m_dataType->getCategory() == Type::Category::Struct) |
|||
{ |
|||
// stack layout: ref
|
|||
auto const& structType = dynamic_cast<StructType const&>(*m_dataType); |
|||
for (auto const& member: structType.getMembers()) |
|||
{ |
|||
// zero each member that is not a mapping
|
|||
TypePointer const& memberType = member.second; |
|||
if (memberType->getCategory() == Type::Category::Mapping) |
|||
continue; |
|||
m_context << structType.getStorageOffsetOfMember(member.first) |
|||
<< eth::Instruction::DUP2 << eth::Instruction::ADD; |
|||
StorageItem(m_context, memberType).setToZero(); |
|||
} |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
else |
|||
{ |
|||
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; |
|||
} |
|||
} |
|||
@ -0,0 +1,112 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2015 |
|||
* LValues for use in the expresison compiler. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <libevmcore/SourceLocation.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
class Declaration; |
|||
class Type; |
|||
class CompilerContext; |
|||
|
|||
/**
|
|||
* Abstract class used to retrieve, delete and store data in lvalues/variables. |
|||
*/ |
|||
class LValue |
|||
{ |
|||
protected: |
|||
LValue(CompilerContext& _compilerContext, std::shared_ptr<Type const> const& _dataType): |
|||
m_context(_compilerContext), m_dataType(_dataType) {} |
|||
|
|||
public: |
|||
/// @returns true if this lvalue reference type occupies a slot on the stack.
|
|||
virtual bool storesReferenceOnStack() const = 0; |
|||
/// Copies the value of the current lvalue to the top of the stack and, if @a _remove is true,
|
|||
/// also removes the reference from the stack.
|
|||
/// @a _location source location of the current expression, used for error reporting.
|
|||
virtual void retrieveValue(SourceLocation const& _location, bool _remove = false) const = 0; |
|||
/// Moves a value from the stack to the lvalue. Removes the value if @a _move is true.
|
|||
/// @a _location is the source location of the expression that caused this operation.
|
|||
/// Stack pre: value [lvalue_ref]
|
|||
/// Stack post if !_move: value_of(lvalue_ref)
|
|||
virtual void storeValue(Type const& _sourceType, |
|||
SourceLocation const& _location = SourceLocation(), bool _move = false) const = 0; |
|||
/// Stores zero in the lvalue.
|
|||
/// @a _location is the source location of the requested operation
|
|||
virtual void setToZero(SourceLocation const& _location = SourceLocation()) const = 0; |
|||
|
|||
protected: |
|||
CompilerContext& m_context; |
|||
std::shared_ptr<Type const> m_dataType; |
|||
}; |
|||
|
|||
/**
|
|||
* Local variable that is completely stored on the stack. |
|||
*/ |
|||
class StackVariable: public LValue |
|||
{ |
|||
public: |
|||
explicit StackVariable(CompilerContext& _compilerContext, Declaration const& _declaration); |
|||
|
|||
virtual bool storesReferenceOnStack() const { return false; } |
|||
virtual void retrieveValue(SourceLocation const& _location, bool _remove = false) const override; |
|||
virtual void storeValue(Type const& _sourceType, |
|||
SourceLocation const& _location = SourceLocation(), bool _move = false) const override; |
|||
virtual void setToZero(SourceLocation const& _location = SourceLocation()) const override; |
|||
|
|||
private: |
|||
/// Base stack offset (@see CompilerContext::getBaseStackOffsetOfVariable) of the local variable.
|
|||
unsigned m_baseStackOffset; |
|||
/// Number of stack elements occupied by the value (not the reference).
|
|||
unsigned m_size; |
|||
}; |
|||
|
|||
/**
|
|||
* Reference to some item in storage. The (starting) position of the item is stored on the stack. |
|||
*/ |
|||
class StorageItem: public LValue |
|||
{ |
|||
public: |
|||
/// Constructs the LValue and pushes the location of @a _declaration onto the stack.
|
|||
explicit StorageItem(CompilerContext& _compilerContext, Declaration const& _declaration); |
|||
/// Constructs the LValue and assumes that the storage reference is already on the stack.
|
|||
explicit StorageItem(CompilerContext& _compilerContext, std::shared_ptr<Type const> const& _type); |
|||
virtual bool storesReferenceOnStack() const { return true; } |
|||
virtual void retrieveValue(SourceLocation const& _location, bool _remove = false) const override; |
|||
virtual void storeValue(Type const& _sourceType, |
|||
SourceLocation const& _location = SourceLocation(), bool _move = false) const override; |
|||
virtual void setToZero(SourceLocation const& _location = SourceLocation()) const override; |
|||
|
|||
private: |
|||
/// Number of stack elements occupied by the value (not the reference).
|
|||
/// Only used for value types.
|
|||
unsigned m_size; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
Loading…
Reference in new issue