Paweł Bylica
10 years ago
95 changed files with 5928 additions and 3100 deletions
File diff suppressed because it is too large
@ -0,0 +1,61 @@ |
|||
/*
|
|||
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 2014 |
|||
* Utilities for the solidity compiler. |
|||
*/ |
|||
|
|||
#include <utility> |
|||
#include <numeric> |
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/Compiler.h> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
void CompilerContext::initializeLocalVariables(unsigned _numVariables) |
|||
{ |
|||
if (_numVariables > 0) |
|||
{ |
|||
*this << u256(0); |
|||
for (unsigned i = 1; i < _numVariables; ++i) |
|||
*this << eth::Instruction::DUP1; |
|||
m_asm.adjustDeposit(-_numVariables); |
|||
} |
|||
} |
|||
|
|||
int CompilerContext::getStackPositionOfVariable(Declaration const& _declaration) |
|||
{ |
|||
auto res = find(begin(m_localVariables), end(m_localVariables), &_declaration); |
|||
if (asserts(res != m_localVariables.end())) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Variable not found on stack.")); |
|||
return end(m_localVariables) - res - 1 + m_asm.deposit(); |
|||
} |
|||
|
|||
eth::AssemblyItem CompilerContext::getFunctionEntryLabel(FunctionDefinition const& _function) const |
|||
{ |
|||
auto res = m_functionEntryLabels.find(&_function); |
|||
if (asserts(res != m_functionEntryLabels.end())) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Function entry label not found.")); |
|||
return res->second.tag(); |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,89 @@ |
|||
/*
|
|||
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 2014 |
|||
* Utilities for the solidity compiler. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <ostream> |
|||
#include <libevmface/Instruction.h> |
|||
#include <liblll/Assembly.h> |
|||
#include <libsolidity/Types.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
|
|||
/**
|
|||
* Context to be shared by all units that compile the same contract. |
|||
* It stores the generated bytecode and the position of identifiers in memory and on the stack. |
|||
*/ |
|||
class CompilerContext |
|||
{ |
|||
public: |
|||
CompilerContext() {} |
|||
|
|||
void startNewFunction() { m_localVariables.clear(); m_asm.setDeposit(0); } |
|||
void initializeLocalVariables(unsigned _numVariables); |
|||
void addVariable(VariableDeclaration const& _declaration) { m_localVariables.push_back(&_declaration); } |
|||
/// Returns the distance of the given local variable from the top of the stack.
|
|||
int getStackPositionOfVariable(Declaration const& _declaration); |
|||
|
|||
void addFunction(FunctionDefinition const& _function) { m_functionEntryLabels.insert(std::make_pair(&_function, m_asm.newTag())); } |
|||
eth::AssemblyItem getFunctionEntryLabel(FunctionDefinition const& _function) const; |
|||
|
|||
void adjustStackOffset(int _adjustment) { m_asm.adjustDeposit(_adjustment); } |
|||
|
|||
/// Appends a JUMPI instruction to a new tag and @returns the tag
|
|||
eth::AssemblyItem appendConditionalJump() { return m_asm.appendJumpI().tag(); } |
|||
/// Appends a JUMPI instruction to @a _tag
|
|||
CompilerContext& appendConditionalJumpTo(eth::AssemblyItem const& _tag) { m_asm.appendJumpI(_tag); return *this; } |
|||
/// Appends a JUMP to a new tag and @returns the tag
|
|||
eth::AssemblyItem appendJump() { return m_asm.appendJump().tag(); } |
|||
/// Appends a JUMP to a specific tag
|
|||
CompilerContext& appendJumpTo(eth::AssemblyItem const& _tag) { m_asm.appendJump(_tag); return *this; } |
|||
/// Appends pushing of a new tag and @returns the new tag.
|
|||
eth::AssemblyItem pushNewTag() { return m_asm.append(m_asm.newPushTag()).tag(); } |
|||
/// @returns a new tag without pushing any opcodes or data
|
|||
eth::AssemblyItem newTag() { return m_asm.newTag(); } |
|||
/// Adds a subroutine to the code (in the data section) and pushes its size (via a tag)
|
|||
/// on the stack. @returns the assembly item corresponding to the pushed subroutine, i.e. its offset.
|
|||
eth::AssemblyItem addSubroutine(eth::Assembly const& _assembly) { return m_asm.appendSubSize(_assembly); } |
|||
|
|||
/// Append elements to the current instruction list and adjust @a m_stackOffset.
|
|||
CompilerContext& operator<<(eth::AssemblyItem const& _item) { m_asm.append(_item); return *this; } |
|||
CompilerContext& operator<<(eth::Instruction _instruction) { m_asm.append(_instruction); return *this; } |
|||
CompilerContext& operator<<(u256 const& _value) { m_asm.append(_value); return *this; } |
|||
CompilerContext& operator<<(bytes const& _data) { m_asm.append(_data); return *this; } |
|||
|
|||
eth::Assembly const& getAssembly() const { return m_asm; } |
|||
void streamAssembly(std::ostream& _stream) const { _stream << m_asm; } |
|||
bytes getAssembledBytecode() const { return m_asm.assemble(); } |
|||
private: |
|||
eth::Assembly m_asm; |
|||
|
|||
/// Offsets of local variables on the stack.
|
|||
std::vector<Declaration const*> m_localVariables; |
|||
/// Labels pointing to the entry points of funcitons.
|
|||
std::map<FunctionDefinition const*, eth::AssemblyItem> m_functionEntryLabels; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,49 @@ |
|||
/*
|
|||
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 2014 |
|||
* Full-stack compiler that converts a source code string to bytecode. |
|||
*/ |
|||
|
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/Scanner.h> |
|||
#include <libsolidity/Parser.h> |
|||
#include <libsolidity/NameAndTypeResolver.h> |
|||
#include <libsolidity/Compiler.h> |
|||
#include <libsolidity/CompilerStack.h> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
bytes CompilerStack::compile(std::string const& _sourceCode, shared_ptr<Scanner> _scanner) |
|||
{ |
|||
if (!_scanner) |
|||
_scanner = make_shared<Scanner>(); |
|||
_scanner->reset(CharStream(_sourceCode)); |
|||
|
|||
ASTPointer<ContractDefinition> contract = Parser().parse(_scanner); |
|||
NameAndTypeResolver().resolveNamesAndTypes(*contract); |
|||
return Compiler::compile(*contract); |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
/*
|
|||
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 2014 |
|||
* Full-stack compiler that converts a source code string to bytecode. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <string> |
|||
#include <memory> |
|||
#include <libdevcore/Common.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
class Scanner; // forward
|
|||
|
|||
class CompilerStack |
|||
{ |
|||
public: |
|||
/// Compile the given @a _sourceCode to bytecode. If a scanner is provided, it is used for
|
|||
/// scanning the source code - this is useful for printing exception information.
|
|||
static bytes compile(std::string const& _sourceCode, std::shared_ptr<Scanner> _scanner = std::shared_ptr<Scanner>()); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,410 @@ |
|||
/*
|
|||
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 2014 |
|||
* Solidity AST to EVM bytecode compiler for expressions. |
|||
*/ |
|||
|
|||
#include <utility> |
|||
#include <numeric> |
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/ExpressionCompiler.h> |
|||
#include <libsolidity/CompilerContext.h> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
void ExpressionCompiler::compileExpression(CompilerContext& _context, Expression& _expression) |
|||
{ |
|||
ExpressionCompiler compiler(_context); |
|||
_expression.accept(compiler); |
|||
} |
|||
|
|||
bool ExpressionCompiler::visit(Assignment& _assignment) |
|||
{ |
|||
m_currentLValue = nullptr; |
|||
|
|||
Expression& rightHandSide = _assignment.getRightHandSide(); |
|||
rightHandSide.accept(*this); |
|||
Type const& resultType = *_assignment.getType(); |
|||
cleanHigherOrderBitsIfNeeded(*rightHandSide.getType(), resultType); |
|||
_assignment.getLeftHandSide().accept(*this); |
|||
|
|||
Token::Value op = _assignment.getAssignmentOperator(); |
|||
if (op != Token::ASSIGN) |
|||
{ |
|||
// compound assignment
|
|||
m_context << eth::Instruction::SWAP1; |
|||
appendOrdinaryBinaryOperatorCode(Token::AssignmentToBinaryOp(op), resultType); |
|||
} |
|||
else |
|||
m_context << eth::Instruction::POP; //@todo do not retrieve the value in the first place
|
|||
|
|||
storeInLValue(_assignment); |
|||
return false; |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation) |
|||
{ |
|||
//@todo type checking and creating code for an operator should be in the same place:
|
|||
// the operator should know how to convert itself and to which types it applies, so
|
|||
// put this code together with "Type::acceptsBinary/UnaryOperator" into a class that
|
|||
// represents the operator
|
|||
switch (_unaryOperation.getOperator()) |
|||
{ |
|||
case Token::NOT: // !
|
|||
m_context << eth::Instruction::ISZERO; |
|||
break; |
|||
case Token::BIT_NOT: // ~
|
|||
m_context << eth::Instruction::NOT; |
|||
break; |
|||
case Token::DELETE: // delete
|
|||
{ |
|||
// a -> a xor a (= 0).
|
|||
// @todo semantics change for complex types
|
|||
m_context << eth::Instruction::DUP1 << eth::Instruction::XOR; |
|||
storeInLValue(_unaryOperation); |
|||
break; |
|||
} |
|||
case Token::INC: // ++ (pre- or postfix)
|
|||
case Token::DEC: // -- (pre- or postfix)
|
|||
if (!_unaryOperation.isPrefixOperation()) |
|||
m_context << eth::Instruction::DUP1; |
|||
m_context << u256(1); |
|||
if (_unaryOperation.getOperator() == Token::INC) |
|||
m_context << eth::Instruction::ADD; |
|||
else |
|||
m_context << eth::Instruction::SWAP1 << eth::Instruction::SUB; // @todo avoid the swap
|
|||
if (_unaryOperation.isPrefixOperation()) |
|||
storeInLValue(_unaryOperation); |
|||
else |
|||
moveToLValue(_unaryOperation); |
|||
break; |
|||
case Token::ADD: // +
|
|||
// unary add, so basically no-op
|
|||
break; |
|||
case Token::SUB: // -
|
|||
m_context << u256(0) << eth::Instruction::SUB; |
|||
break; |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid unary operator: " + |
|||
string(Token::toString(_unaryOperation.getOperator())))); |
|||
} |
|||
} |
|||
|
|||
bool ExpressionCompiler::visit(BinaryOperation& _binaryOperation) |
|||
{ |
|||
Expression& leftExpression = _binaryOperation.getLeftExpression(); |
|||
Expression& rightExpression = _binaryOperation.getRightExpression(); |
|||
Type const& resultType = *_binaryOperation.getType(); |
|||
Token::Value const op = _binaryOperation.getOperator(); |
|||
|
|||
if (op == Token::AND || op == Token::OR) |
|||
{ |
|||
// special case: short-circuiting
|
|||
appendAndOrOperatorCode(_binaryOperation); |
|||
} |
|||
else if (Token::isCompareOp(op)) |
|||
{ |
|||
leftExpression.accept(*this); |
|||
rightExpression.accept(*this); |
|||
|
|||
// the types to compare have to be the same, but the resulting type is always bool
|
|||
if (asserts(*leftExpression.getType() == *rightExpression.getType())) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError()); |
|||
appendCompareOperatorCode(op, *leftExpression.getType()); |
|||
} |
|||
else |
|||
{ |
|||
leftExpression.accept(*this); |
|||
cleanHigherOrderBitsIfNeeded(*leftExpression.getType(), resultType); |
|||
rightExpression.accept(*this); |
|||
cleanHigherOrderBitsIfNeeded(*rightExpression.getType(), resultType); |
|||
appendOrdinaryBinaryOperatorCode(op, resultType); |
|||
} |
|||
|
|||
// do not visit the child nodes, we already did that explicitly
|
|||
return false; |
|||
} |
|||
|
|||
bool ExpressionCompiler::visit(FunctionCall& _functionCall) |
|||
{ |
|||
if (_functionCall.isTypeConversion()) |
|||
{ |
|||
//@todo we only have integers and bools for now which cannot be explicitly converted
|
|||
if (asserts(_functionCall.getArguments().size() == 1)) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError()); |
|||
Expression& firstArgument = *_functionCall.getArguments().front(); |
|||
firstArgument.accept(*this); |
|||
cleanHigherOrderBitsIfNeeded(*firstArgument.getType(), *_functionCall.getType()); |
|||
} |
|||
else |
|||
{ |
|||
// Calling convention: Caller pushes return address and arguments
|
|||
// Callee removes them and pushes return values
|
|||
m_currentLValue = nullptr; |
|||
_functionCall.getExpression().accept(*this); |
|||
FunctionDefinition const& function = dynamic_cast<FunctionDefinition&>(*m_currentLValue); |
|||
|
|||
eth::AssemblyItem returnLabel = m_context.pushNewTag(); |
|||
std::vector<ASTPointer<Expression>> const& arguments = _functionCall.getArguments(); |
|||
if (asserts(arguments.size() == function.getParameters().size())) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError()); |
|||
for (unsigned i = 0; i < arguments.size(); ++i) |
|||
{ |
|||
arguments[i]->accept(*this); |
|||
cleanHigherOrderBitsIfNeeded(*arguments[i]->getType(), |
|||
*function.getParameters()[i]->getType()); |
|||
} |
|||
|
|||
m_context.appendJumpTo(m_context.getFunctionEntryLabel(function)); |
|||
m_context << returnLabel; |
|||
|
|||
// callee adds return parameters, but removes arguments and return label
|
|||
m_context.adjustStackOffset(function.getReturnParameters().size() - arguments.size() - 1); |
|||
|
|||
// @todo for now, the return value of a function is its first return value, so remove
|
|||
// all others
|
|||
for (unsigned i = 1; i < function.getReturnParameters().size(); ++i) |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(MemberAccess&) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(IndexAccess&) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Identifier& _identifier) |
|||
{ |
|||
m_currentLValue = _identifier.getReferencedDeclaration(); |
|||
switch (_identifier.getType()->getCategory()) |
|||
{ |
|||
case Type::Category::BOOL: |
|||
case Type::Category::INTEGER: |
|||
case Type::Category::REAL: |
|||
{ |
|||
//@todo we also have to check where to retrieve them from once we add storage variables
|
|||
unsigned stackPos = stackPositionOfLValue(); |
|||
if (stackPos >= 15) //@todo correct this by fetching earlier or moving to memory
|
|||
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_identifier.getLocation()) |
|||
<< errinfo_comment("Stack too deep.")); |
|||
m_context << eth::dupInstruction(stackPos + 1); |
|||
break; |
|||
} |
|||
default: |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Literal& _literal) |
|||
{ |
|||
switch (_literal.getType()->getCategory()) |
|||
{ |
|||
case Type::Category::INTEGER: |
|||
case Type::Category::BOOL: |
|||
m_context << _literal.getType()->literalValue(_literal); |
|||
break; |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Only integer and boolean literals implemented for now.")); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::cleanHigherOrderBitsIfNeeded(Type const& _typeOnStack, Type const& _targetType) |
|||
{ |
|||
// If the type of one of the operands is extended, we need to remove all
|
|||
// higher-order bits that we might have ignored in previous operations.
|
|||
// @todo: store in the AST whether the operand might have "dirty" higher
|
|||
// order bits
|
|||
|
|||
if (_typeOnStack == _targetType) |
|||
return; |
|||
if (_typeOnStack.getCategory() == Type::Category::INTEGER && |
|||
_targetType.getCategory() == Type::Category::INTEGER) |
|||
{ |
|||
//@todo
|
|||
} |
|||
else |
|||
{ |
|||
// If we get here, there is either an implementation missing to clean higher oder bits
|
|||
// for non-integer types that are explicitly convertible or we got here in error.
|
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid type conversion requested.")); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation& _binaryOperation) |
|||
{ |
|||
Token::Value const op = _binaryOperation.getOperator(); |
|||
if (asserts(op == Token::OR || op == Token::AND)) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError()); |
|||
|
|||
_binaryOperation.getLeftExpression().accept(*this); |
|||
m_context << eth::Instruction::DUP1; |
|||
if (op == Token::AND) |
|||
m_context << eth::Instruction::ISZERO; |
|||
eth::AssemblyItem endLabel = m_context.appendConditionalJump(); |
|||
m_context << eth::Instruction::POP; |
|||
_binaryOperation.getRightExpression().accept(*this); |
|||
m_context << endLabel; |
|||
} |
|||
|
|||
void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
if (_operator == Token::EQ || _operator == Token::NE) |
|||
{ |
|||
m_context << eth::Instruction::EQ; |
|||
if (_operator == Token::NE) |
|||
m_context << eth::Instruction::ISZERO; |
|||
} |
|||
else |
|||
{ |
|||
IntegerType const& type = dynamic_cast<IntegerType const&>(_type); |
|||
bool const isSigned = type.isSigned(); |
|||
|
|||
// note that EVM opcodes compare like "stack[0] < stack[1]",
|
|||
// but our left value is at stack[1], so everyhing is reversed.
|
|||
switch (_operator) |
|||
{ |
|||
case Token::GTE: |
|||
m_context << (isSigned ? eth::Instruction::SGT : eth::Instruction::GT) |
|||
<< eth::Instruction::ISZERO; |
|||
break; |
|||
case Token::LTE: |
|||
m_context << (isSigned ? eth::Instruction::SLT : eth::Instruction::LT) |
|||
<< eth::Instruction::ISZERO; |
|||
break; |
|||
case Token::GT: |
|||
m_context << (isSigned ? eth::Instruction::SLT : eth::Instruction::LT); |
|||
break; |
|||
case Token::LT: |
|||
m_context << (isSigned ? eth::Instruction::SGT : eth::Instruction::GT); |
|||
break; |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown comparison operator.")); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendOrdinaryBinaryOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
if (Token::isArithmeticOp(_operator)) |
|||
appendArithmeticOperatorCode(_operator, _type); |
|||
else if (Token::isBitOp(_operator)) |
|||
appendBitOperatorCode(_operator); |
|||
else if (Token::isShiftOp(_operator)) |
|||
appendShiftOperatorCode(_operator); |
|||
else |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown binary operator.")); |
|||
} |
|||
|
|||
void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
IntegerType const& type = dynamic_cast<IntegerType const&>(_type); |
|||
bool const isSigned = type.isSigned(); |
|||
|
|||
switch (_operator) |
|||
{ |
|||
case Token::ADD: |
|||
m_context << eth::Instruction::ADD; |
|||
break; |
|||
case Token::SUB: |
|||
m_context << eth::Instruction::SWAP1 << eth::Instruction::SUB; |
|||
break; |
|||
case Token::MUL: |
|||
m_context << eth::Instruction::MUL; |
|||
break; |
|||
case Token::DIV: |
|||
m_context << eth::Instruction::SWAP1 << (isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV); |
|||
break; |
|||
case Token::MOD: |
|||
m_context << eth::Instruction::SWAP1 << (isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD); |
|||
break; |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown arithmetic operator.")); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator) |
|||
{ |
|||
switch (_operator) |
|||
{ |
|||
case Token::BIT_OR: |
|||
m_context << eth::Instruction::OR; |
|||
break; |
|||
case Token::BIT_AND: |
|||
m_context << eth::Instruction::AND; |
|||
break; |
|||
case Token::BIT_XOR: |
|||
m_context << eth::Instruction::XOR; |
|||
break; |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown bit operator.")); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendShiftOperatorCode(Token::Value _operator) |
|||
{ |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Shift operators not yet implemented.")); |
|||
switch (_operator) |
|||
{ |
|||
case Token::SHL: |
|||
break; |
|||
case Token::SAR: |
|||
break; |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown shift operator.")); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::storeInLValue(Expression const& _expression) |
|||
{ |
|||
moveToLValue(_expression); |
|||
unsigned stackPos = stackPositionOfLValue(); |
|||
if (stackPos > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation()) |
|||
<< errinfo_comment("Stack too deep.")); |
|||
m_context << eth::dupInstruction(stackPos + 1); |
|||
} |
|||
|
|||
void ExpressionCompiler::moveToLValue(Expression const& _expression) |
|||
{ |
|||
unsigned stackPos = stackPositionOfLValue(); |
|||
if (stackPos > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_expression.getLocation()) |
|||
<< errinfo_comment("Stack too deep.")); |
|||
else if (stackPos > 0) |
|||
m_context << eth::swapInstruction(stackPos) << eth::Instruction::POP; |
|||
} |
|||
|
|||
unsigned ExpressionCompiler::stackPositionOfLValue() const |
|||
{ |
|||
if (asserts(m_currentLValue)) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("LValue not available on request.")); |
|||
return m_context.getStackPositionOfVariable(*m_currentLValue); |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,79 @@ |
|||
/*
|
|||
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 2014 |
|||
* Solidity AST to EVM bytecode compiler for expressions. |
|||
*/ |
|||
|
|||
#include <libsolidity/ASTVisitor.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
class CompilerContext; // forward
|
|||
|
|||
/// Compiler for expressions, i.e. converts an AST tree whose root is an Expression into a stream
|
|||
/// of EVM instructions. It needs a compiler context that is the same for the whole compilation
|
|||
/// unit.
|
|||
class ExpressionCompiler: private ASTVisitor |
|||
{ |
|||
public: |
|||
/// Compile the given @a _expression into the @a _context.
|
|||
static void compileExpression(CompilerContext& _context, Expression& _expression); |
|||
|
|||
/// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type.
|
|||
static void cleanHigherOrderBitsIfNeeded(Type const& _typeOnStack, Type const& _targetType); |
|||
|
|||
private: |
|||
ExpressionCompiler(CompilerContext& _compilerContext): m_currentLValue(nullptr), m_context(_compilerContext) {} |
|||
|
|||
virtual bool visit(Assignment& _assignment) override; |
|||
virtual void endVisit(UnaryOperation& _unaryOperation) override; |
|||
virtual bool visit(BinaryOperation& _binaryOperation) override; |
|||
virtual bool visit(FunctionCall& _functionCall) override; |
|||
virtual void endVisit(MemberAccess& _memberAccess) override; |
|||
virtual void endVisit(IndexAccess& _indexAccess) override; |
|||
virtual void endVisit(Identifier& _identifier) override; |
|||
virtual void endVisit(Literal& _literal) override; |
|||
|
|||
///@{
|
|||
///@name Append code for various operator types
|
|||
void appendAndOrOperatorCode(BinaryOperation& _binaryOperation); |
|||
void appendCompareOperatorCode(Token::Value _operator, Type const& _type); |
|||
void appendOrdinaryBinaryOperatorCode(Token::Value _operator, Type const& _type); |
|||
|
|||
void appendArithmeticOperatorCode(Token::Value _operator, Type const& _type); |
|||
void appendBitOperatorCode(Token::Value _operator); |
|||
void appendShiftOperatorCode(Token::Value _operator); |
|||
/// @}
|
|||
|
|||
/// Stores the value on top of the stack in the current lvalue and copies that value to the
|
|||
/// top of the stack again
|
|||
void storeInLValue(Expression const& _expression); |
|||
/// The same as storeInLValue but do not again retrieve the value to the top of the stack.
|
|||
void moveToLValue(Expression const& _expression); |
|||
/// Returns the position of @a m_currentLValue in the stack, where 0 is the top of the stack.
|
|||
unsigned stackPositionOfLValue() const; |
|||
|
|||
Declaration* m_currentLValue; |
|||
CompilerContext& m_context; |
|||
}; |
|||
|
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,229 @@ |
|||
|
|||
/*
|
|||
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 2014 |
|||
* Unit tests for the solidity expression compiler, testing the behaviour of the code. |
|||
*/ |
|||
|
|||
#include <string> |
|||
#include <boost/test/unit_test.hpp> |
|||
#include <libethereum/State.h> |
|||
#include <libethereum/Executive.h> |
|||
#include <libsolidity/CompilerStack.h> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
namespace test |
|||
{ |
|||
|
|||
class ExecutionFramework |
|||
{ |
|||
public: |
|||
ExecutionFramework() { g_logVerbosity = 0; } |
|||
|
|||
bytes compileAndRun(std::string const& _sourceCode) |
|||
{ |
|||
bytes code = dev::solidity::CompilerStack::compile(_sourceCode); |
|||
sendMessage(code, true); |
|||
return m_output; |
|||
} |
|||
|
|||
bytes callFunction(byte _index, bytes const& _data) |
|||
{ |
|||
sendMessage(bytes(1, _index) + _data, false); |
|||
return m_output; |
|||
} |
|||
|
|||
bytes callFunction(byte _index, u256 const& _argument1) |
|||
{ |
|||
callFunction(_index, toBigEndian(_argument1)); |
|||
return m_output; |
|||
} |
|||
|
|||
private: |
|||
void sendMessage(bytes const& _data, bool _isCreation) |
|||
{ |
|||
eth::Executive executive(m_state); |
|||
eth::Transaction t = _isCreation ? eth::Transaction(0, m_gasPrice, m_gas, _data) |
|||
: eth::Transaction(0, m_gasPrice, m_gas, m_contractAddress, _data); |
|||
bytes transactionRLP = t.rlp(); |
|||
try |
|||
{ |
|||
// this will throw since the transaction is invalid, but it should nevertheless store the transaction
|
|||
executive.setup(&transactionRLP); |
|||
} |
|||
catch (...) {} |
|||
if (_isCreation) |
|||
{ |
|||
BOOST_REQUIRE(!executive.create(Address(), 0, m_gasPrice, m_gas, &_data, Address())); |
|||
m_contractAddress = executive.newAddress(); |
|||
BOOST_REQUIRE(m_state.addressHasCode(m_contractAddress)); |
|||
} |
|||
else |
|||
BOOST_REQUIRE(!executive.call(m_contractAddress, Address(), 0, m_gasPrice, &_data, m_gas, Address())); |
|||
BOOST_REQUIRE(executive.go()); |
|||
executive.finalize(); |
|||
m_output = executive.out().toBytes(); |
|||
} |
|||
|
|||
Address m_contractAddress; |
|||
eth::State m_state; |
|||
u256 const m_gasPrice = 100 * eth::szabo; |
|||
u256 const m_gas = 1000000; |
|||
bytes m_output; |
|||
}; |
|||
|
|||
BOOST_AUTO_TEST_SUITE(SolidityCompilerEndToEndTest) |
|||
|
|||
BOOST_AUTO_TEST_CASE(smoke_test) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f(uint a) returns(uint d) { return a * 7; }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
u256 a = 0x200030004; |
|||
bytes result = framework.callFunction(0, a); |
|||
BOOST_CHECK(result == toBigEndian(a * 7)); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(empty_contract) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(0, bytes()).empty()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(recursive_calls) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f(uint n) returns(uint nfac) {\n" |
|||
" if (n <= 1) return 1;\n" |
|||
" else return n * f(n - 1);\n" |
|||
" }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(0, u256(0)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(1)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(2)) == toBigEndian(u256(2))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(3)) == toBigEndian(u256(6))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(4)) == toBigEndian(u256(24))); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(while_loop) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f(uint n) returns(uint nfac) {\n" |
|||
" nfac = 1;\n" |
|||
" var i = 2;\n" |
|||
" while (i <= n) nfac *= i++;\n" |
|||
" }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(0, u256(0)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(1)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(2)) == toBigEndian(u256(2))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(3)) == toBigEndian(u256(6))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(4)) == toBigEndian(u256(24))); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(calling_other_functions) |
|||
{ |
|||
// note that the index of a function is its index in the sorted sequence of functions
|
|||
char const* sourceCode = "contract collatz {\n" |
|||
" function run(uint x) returns(uint y) {\n" |
|||
" while ((y = x) > 1) {\n" |
|||
" if (x % 2 == 0) x = evenStep(x);\n" |
|||
" else x = oddStep(x);\n" |
|||
" }\n" |
|||
" }\n" |
|||
" function evenStep(uint x) returns(uint y) {\n" |
|||
" return x / 2;\n" |
|||
" }\n" |
|||
" function oddStep(uint x) returns(uint y) {\n" |
|||
" return 3 * x + 1;\n" |
|||
" }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(2, u256(0)) == toBigEndian(u256(0))); |
|||
BOOST_CHECK(framework.callFunction(2, u256(1)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(2, u256(2)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(2, u256(8)) == toBigEndian(u256(1))); |
|||
BOOST_CHECK(framework.callFunction(2, u256(127)) == toBigEndian(u256(1))); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(many_local_variables) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function run(uint x1, uint x2, uint x3) returns(uint y) {\n" |
|||
" var a = 0x1; var b = 0x10; var c = 0x100;\n" |
|||
" y = a + b + c + x1 + x2 + x3;\n" |
|||
" y += b + x2;\n" |
|||
" }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(0, toBigEndian(u256(0x1000)) + toBigEndian(u256(0x10000)) + toBigEndian(u256(0x100000))) |
|||
== toBigEndian(u256(0x121121))); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(multiple_return_values) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function run(bool x1, uint x2) returns(uint y1, bool y2, uint y3) {\n" |
|||
" y1 = x2; y2 = x1;\n" |
|||
" }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(0, bytes(1, 1) + toBigEndian(u256(0xcd))) |
|||
== toBigEndian(u256(0xcd)) + bytes(1, 1) + toBigEndian(u256(0))); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(short_circuiting) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function run(uint x) returns(uint y) {\n" |
|||
" x == 0 || ((x = 8) > 0);\n" |
|||
" return x;" |
|||
" }\n" |
|||
"}\n"; |
|||
ExecutionFramework framework; |
|||
framework.compileAndRun(sourceCode); |
|||
BOOST_CHECK(framework.callFunction(0, u256(0)) == toBigEndian(u256(0))); |
|||
BOOST_CHECK(framework.callFunction(0, u256(1)) == toBigEndian(u256(8))); |
|||
} |
|||
|
|||
//@todo test smaller types
|
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
} |
|||
} |
|||
} // end namespaces
|
|||
|
|||
@ -0,0 +1,352 @@ |
|||
|
|||
/*
|
|||
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 2014 |
|||
* Unit tests for the solidity expression compiler. |
|||
*/ |
|||
|
|||
#include <string> |
|||
|
|||
#include <libdevcore/Log.h> |
|||
#include <libsolidity/Scanner.h> |
|||
#include <libsolidity/Parser.h> |
|||
#include <libsolidity/NameAndTypeResolver.h> |
|||
#include <libsolidity/CompilerContext.h> |
|||
#include <libsolidity/ExpressionCompiler.h> |
|||
#include <libsolidity/AST.h> |
|||
#include <boost/test/unit_test.hpp> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
namespace test |
|||
{ |
|||
|
|||
namespace |
|||
{ |
|||
|
|||
/// Helper class that extracts the first expression in an AST.
|
|||
class FirstExpressionExtractor: private ASTVisitor |
|||
{ |
|||
public: |
|||
FirstExpressionExtractor(ASTNode& _node): m_expression(nullptr) { _node.accept(*this); } |
|||
Expression* getExpression() const { return m_expression; } |
|||
private: |
|||
virtual bool visit(Expression& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(Assignment& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(UnaryOperation& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(BinaryOperation& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(FunctionCall& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(MemberAccess& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(IndexAccess& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(PrimaryExpression& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(Identifier& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(ElementaryTypeNameExpression& _expression) override { return checkExpression(_expression); } |
|||
virtual bool visit(Literal& _expression) override { return checkExpression(_expression); } |
|||
bool checkExpression(Expression& _expression) |
|||
{ |
|||
if (m_expression == nullptr) |
|||
m_expression = &_expression; |
|||
return false; |
|||
} |
|||
private: |
|||
Expression* m_expression; |
|||
}; |
|||
|
|||
Declaration const& resolveDeclaration(vector<string> const& _namespacedName, |
|||
NameAndTypeResolver const& _resolver) |
|||
{ |
|||
Declaration const* declaration = nullptr; |
|||
for (string const& namePart: _namespacedName) |
|||
BOOST_REQUIRE(declaration = _resolver.resolveName(namePart, declaration)); |
|||
BOOST_REQUIRE(declaration); |
|||
return *declaration; |
|||
} |
|||
|
|||
bytes compileFirstExpression(const string& _sourceCode, vector<vector<string>> _functions = {}, |
|||
vector<vector<string>> _localVariables = {}) |
|||
{ |
|||
Parser parser; |
|||
ASTPointer<ContractDefinition> contract; |
|||
BOOST_REQUIRE_NO_THROW(contract = parser.parse(make_shared<Scanner>(CharStream(_sourceCode)))); |
|||
NameAndTypeResolver resolver; |
|||
BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract)); |
|||
FirstExpressionExtractor extractor(*contract); |
|||
BOOST_REQUIRE(extractor.getExpression() != nullptr); |
|||
|
|||
CompilerContext context; |
|||
for (vector<string> const& function: _functions) |
|||
context.addFunction(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver))); |
|||
for (vector<string> const& variable: _localVariables) |
|||
context.addVariable(dynamic_cast<VariableDeclaration const&>(resolveDeclaration(variable, resolver))); |
|||
|
|||
ExpressionCompiler::compileExpression(context, *extractor.getExpression()); |
|||
|
|||
for (vector<string> const& function: _functions) |
|||
context << context.getFunctionEntryLabel(dynamic_cast<FunctionDefinition const&>(resolveDeclaration(function, resolver))); |
|||
bytes instructions = context.getAssembledBytecode(); |
|||
// debug
|
|||
// cout << eth::disassemble(instructions) << endl;
|
|||
return instructions; |
|||
} |
|||
|
|||
} // end anonymous namespace
|
|||
|
|||
BOOST_AUTO_TEST_SUITE(SolidityExpressionCompiler) |
|||
|
|||
BOOST_AUTO_TEST_CASE(literal_true) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = true; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH1), 0x1}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(literal_false) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = false; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH1), 0x0}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(int_literal) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = 0x12345678901234567890; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90, |
|||
0x12, 0x34, 0x56, 0x78, 0x90}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(comparison) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = (0x10aa < 0x11aa) != true; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH2), 0x10, 0xaa, |
|||
byte(eth::Instruction::PUSH2), 0x11, 0xaa, |
|||
byte(eth::Instruction::GT), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::ISZERO)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(short_circuiting) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = (10 + 8 >= 4 || 2 != 9) != true; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH1), 0xa, |
|||
byte(eth::Instruction::PUSH1), 0x8, |
|||
byte(eth::Instruction::ADD), |
|||
byte(eth::Instruction::PUSH1), 0x4, |
|||
byte(eth::Instruction::GT), |
|||
byte(eth::Instruction::ISZERO), // after this we have 10 + 8 >= 4
|
|||
byte(eth::Instruction::DUP1), |
|||
byte(eth::Instruction::PUSH1), 0x14, |
|||
byte(eth::Instruction::JUMPI), // short-circuit if it is true
|
|||
byte(eth::Instruction::POP), |
|||
byte(eth::Instruction::PUSH1), 0x2, |
|||
byte(eth::Instruction::PUSH1), 0x9, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::ISZERO), // after this we have 2 != 9
|
|||
byte(eth::Instruction::JUMPDEST), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::ISZERO)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(arithmetics) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = (1 * (2 / (3 % (4 + (5 - (6 | (7 & (8 ^ 9)))))))); }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::PUSH1), 0x2, |
|||
byte(eth::Instruction::PUSH1), 0x3, |
|||
byte(eth::Instruction::PUSH1), 0x4, |
|||
byte(eth::Instruction::PUSH1), 0x5, |
|||
byte(eth::Instruction::PUSH1), 0x6, |
|||
byte(eth::Instruction::PUSH1), 0x7, |
|||
byte(eth::Instruction::PUSH1), 0x8, |
|||
byte(eth::Instruction::PUSH1), 0x9, |
|||
byte(eth::Instruction::XOR), |
|||
byte(eth::Instruction::AND), |
|||
byte(eth::Instruction::OR), |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::SUB), |
|||
byte(eth::Instruction::ADD), |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::MOD), |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::DIV), |
|||
byte(eth::Instruction::MUL)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(unary_operators) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f() { var x = !(~+-1 == 2); }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode); |
|||
|
|||
bytes expectation({byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::PUSH1), 0x0, |
|||
byte(eth::Instruction::SUB), |
|||
byte(eth::Instruction::NOT), |
|||
byte(eth::Instruction::PUSH1), 0x2, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::ISZERO)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(unary_inc_dec) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f(uint a) { var x = ((a++ ^ ++a) ^ a--) ^ --a; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "x"}}); |
|||
|
|||
// Stack: a, x
|
|||
bytes expectation({byte(eth::Instruction::DUP2), |
|||
byte(eth::Instruction::DUP1), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::ADD), |
|||
// Stack here: a x a (a+1)
|
|||
byte(eth::Instruction::SWAP3), |
|||
byte(eth::Instruction::POP), // first ++
|
|||
// Stack here: (a+1) x a
|
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::ADD), |
|||
// Stack here: (a+1) x a (a+2)
|
|||
byte(eth::Instruction::SWAP3), |
|||
byte(eth::Instruction::POP), |
|||
// Stack here: (a+2) x a
|
|||
byte(eth::Instruction::DUP3), // second ++
|
|||
byte(eth::Instruction::XOR), |
|||
// Stack here: (a+2) x a^(a+2)
|
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::DUP1), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::SUB), |
|||
// Stack here: (a+2) x a^(a+2) (a+2) (a+1)
|
|||
byte(eth::Instruction::SWAP4), |
|||
byte(eth::Instruction::POP), // first --
|
|||
byte(eth::Instruction::XOR), |
|||
// Stack here: (a+1) x a^(a+2)^(a+2)
|
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::SUB), |
|||
// Stack here: (a+1) x a^(a+2)^(a+2) a
|
|||
byte(eth::Instruction::SWAP3), |
|||
byte(eth::Instruction::POP), // second ++
|
|||
// Stack here: a x a^(a+2)^(a+2)
|
|||
byte(eth::Instruction::DUP3), // will change
|
|||
byte(eth::Instruction::XOR)}); |
|||
// Stack here: a x a^(a+2)^(a+2)^a
|
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(assignment) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f(uint a, uint b) { (a += b) * 2; }" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "b"}}); |
|||
|
|||
// Stack: a, b
|
|||
bytes expectation({byte(eth::Instruction::DUP1), |
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::ADD), |
|||
// Stack here: a b a+b
|
|||
byte(eth::Instruction::SWAP2), |
|||
byte(eth::Instruction::POP), |
|||
byte(eth::Instruction::DUP2), |
|||
// Stack here: a+b b a+b
|
|||
byte(eth::Instruction::PUSH1), 0x2, |
|||
byte(eth::Instruction::MUL)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_CASE(function_call) |
|||
{ |
|||
char const* sourceCode = "contract test {\n" |
|||
" function f(uint a, uint b) { a += g(a + 1, b) * 2; }\n" |
|||
" function g(uint a, uint b) returns (uint c) {}\n" |
|||
"}\n"; |
|||
bytes code = compileFirstExpression(sourceCode, {{"test", "g"}}, |
|||
{{"test", "f", "a"}, {"test", "f", "b"}}); |
|||
|
|||
// Stack: a, b
|
|||
bytes expectation({byte(eth::Instruction::PUSH1), 0x0a, |
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::PUSH1), 0x01, |
|||
byte(eth::Instruction::ADD), |
|||
// Stack here: a b <ret label> (a+1)
|
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::PUSH1), 0x14, |
|||
byte(eth::Instruction::JUMP), |
|||
byte(eth::Instruction::JUMPDEST), |
|||
// Stack here: a b g(a+1, b)
|
|||
byte(eth::Instruction::PUSH1), 0x02, |
|||
byte(eth::Instruction::MUL), |
|||
// Stack here: a b g(a+1, b)*2
|
|||
byte(eth::Instruction::DUP3), |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::ADD), |
|||
// Stack here: a b a+g(a+1, b)*2
|
|||
byte(eth::Instruction::SWAP2), |
|||
byte(eth::Instruction::POP), |
|||
byte(eth::Instruction::DUP2), |
|||
byte(eth::Instruction::JUMPDEST)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
} |
|||
} |
|||
} // end namespaces
|
|||
|
|||
@ -0,0 +1,90 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/** @file stateOriginal.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* State test functions. |
|||
*/ |
|||
|
|||
#include <boost/filesystem/operations.hpp> |
|||
#include <secp256k1/secp256k1.h> |
|||
#include <libethereum/BlockChain.h> |
|||
#include <libethereum/State.h> |
|||
#include <libethereum/Defaults.h> |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
int stateTest() |
|||
{ |
|||
cnote << "Testing State..."; |
|||
|
|||
KeyPair me = sha3("Gav Wood"); |
|||
KeyPair myMiner = sha3("Gav's Miner"); |
|||
// KeyPair you = sha3("123");
|
|||
|
|||
Defaults::setDBPath(boost::filesystem::temp_directory_path().string()); |
|||
|
|||
OverlayDB stateDB = State::openDB(); |
|||
BlockChain bc; |
|||
State s(myMiner.address(), stateDB); |
|||
|
|||
cout << bc; |
|||
|
|||
// Sync up - this won't do much until we use the last state.
|
|||
s.sync(bc); |
|||
|
|||
cout << s; |
|||
|
|||
// Mine to get some ether!
|
|||
s.commitToMine(bc); |
|||
while (!s.mine(100).completed) {} |
|||
s.completeMine(); |
|||
bc.attemptImport(s.blockData(), stateDB); |
|||
|
|||
cout << bc; |
|||
|
|||
s.sync(bc); |
|||
|
|||
cout << s; |
|||
|
|||
// Inject a transaction to transfer funds from miner to me.
|
|||
bytes tx; |
|||
{ |
|||
Transaction t(1000, 0, 0, me.address(), bytes(), s.transactionsFrom(myMiner.address()), myMiner.secret()); |
|||
assert(t.sender() == myMiner.address()); |
|||
tx = t.rlp(); |
|||
} |
|||
s.execute(tx); |
|||
|
|||
cout << s; |
|||
|
|||
// Mine to get some ether and set in stone.
|
|||
s.commitToMine(bc); |
|||
while (!s.mine(100).completed) {} |
|||
s.completeMine(); |
|||
bc.attemptImport(s.blockData(), stateDB); |
|||
|
|||
cout << bc; |
|||
|
|||
s.sync(bc); |
|||
|
|||
cout << s; |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
@ -0,0 +1,44 @@ |
|||
{ |
|||
"ABAcalls0": { |
|||
"env" : { |
|||
"previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6", |
|||
"currentNumber" : "0", |
|||
"currentGasLimit" : "10000000", |
|||
"currentDifficulty" : "256", |
|||
"currentTimestamp" : 1, |
|||
"currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba" |
|||
}, |
|||
"pre" : { |
|||
"095e7baea6a6c7c4c2dfeb977efac326af552d87" : { |
|||
"balance" : "1000000000000000000", |
|||
"nonce" : 0, |
|||
"code" : "{ [[ (PC) ]] (CALL 1000 0x945304eb96065b2a98b57a48a06ae28d285a71b5 24 0 0 0 0) }", |
|||
"storage": {} |
|||
}, |
|||
"945304eb96065b2a98b57a48a06ae28d285a71b5" : { |
|||
"balance" : "23", |
|||
"code" : " { [[ (PC) ]] (ADD 1 (CALL 500 0x095e7baea6a6c7c4c2dfeb977efac326af552d87 23 0 0 0 0)) } ", |
|||
"nonce" : "0", |
|||
"storage" : { |
|||
} |
|||
}, |
|||
"a94f5374fce5edbc8e2a8697c15331677e6ebf0b" : { |
|||
"balance" : "1000000000000000000", |
|||
"nonce" : 0, |
|||
"code" : "", |
|||
"storage": {} |
|||
} |
|||
|
|||
}, |
|||
"transaction" : { |
|||
"nonce" : "0", |
|||
"gasPrice" : "1", |
|||
"gasLimit" : "10000", |
|||
"to" : "095e7baea6a6c7c4c2dfeb977efac326af552d87", |
|||
"value" : "100000", |
|||
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8", |
|||
"data" : "" |
|||
} |
|||
} |
|||
|
|||
} |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
Loading…
Reference in new issue