Christian
10 years ago
9 changed files with 941 additions and 30 deletions
@ -0,0 +1,408 @@ |
|||
/*
|
|||
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. |
|||
*/ |
|||
|
|||
#include <boost/assert.hpp> |
|||
#include <utility> |
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/Compiler.h> |
|||
|
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
|
|||
void CompilerContext::setLabelPosition(uint32_t _label, uint32_t _position) |
|||
{ |
|||
BOOST_ASSERT(m_labelPositions.find(_label) == m_labelPositions.end()); |
|||
m_labelPositions[_label] = _position; |
|||
} |
|||
|
|||
uint32_t CompilerContext::getLabelPosition(uint32_t _label) const |
|||
{ |
|||
auto iter = m_labelPositions.find(_label); |
|||
BOOST_ASSERT(iter != m_labelPositions.end()); |
|||
return iter->second; |
|||
} |
|||
|
|||
void ExpressionCompiler::compile(Expression& _expression) |
|||
{ |
|||
m_assemblyItems.clear(); |
|||
_expression.accept(*this); |
|||
} |
|||
|
|||
bytes ExpressionCompiler::getAssembledBytecode() const |
|||
{ |
|||
bytes assembled; |
|||
assembled.reserve(m_assemblyItems.size()); |
|||
|
|||
// resolve label references
|
|||
for (uint32_t pos = 0; pos < m_assemblyItems.size(); ++pos) |
|||
{ |
|||
AssemblyItem const& item = m_assemblyItems[pos]; |
|||
if (item.getType() == AssemblyItem::Type::LABEL) |
|||
m_context.setLabelPosition(item.getLabel(), pos + 1); |
|||
} |
|||
|
|||
for (AssemblyItem const& item: m_assemblyItems) |
|||
{ |
|||
if (item.getType() == AssemblyItem::Type::LABELREF) |
|||
assembled.push_back(m_context.getLabelPosition(item.getLabel())); |
|||
else |
|||
assembled.push_back(item.getData()); |
|||
} |
|||
|
|||
return assembled; |
|||
} |
|||
|
|||
AssemblyItems ExpressionCompiler::compileExpression(CompilerContext& _context, |
|||
Expression& _expression) |
|||
{ |
|||
ExpressionCompiler compiler(_context); |
|||
compiler.compile(_expression); |
|||
return compiler.getAssemblyItems(); |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Assignment& _assignment) |
|||
{ |
|||
Expression& rightHandSide = _assignment.getRightHandSide(); |
|||
Token::Value op = _assignment.getAssignmentOperator(); |
|||
if (op != Token::ASSIGN) |
|||
{ |
|||
// compound assignment
|
|||
// @todo retrieve lvalue value
|
|||
rightHandSide.accept(*this); |
|||
Type const& resultType = *_assignment.getType(); |
|||
cleanHigherOrderBitsIfNeeded(*rightHandSide.getType(), resultType); |
|||
appendOrdinaryBinaryOperatorCode(Token::AssignmentToBinaryOp(op), resultType); |
|||
} |
|||
else |
|||
rightHandSide.accept(*this); |
|||
// @todo store value
|
|||
} |
|||
|
|||
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: // !
|
|||
append(eth::Instruction::NOT); |
|||
break; |
|||
case Token::BIT_NOT: // ~
|
|||
// ~a modeled as "a xor (0 - 1)" for now
|
|||
append(eth::Instruction::PUSH1); |
|||
append(1); |
|||
append(eth::Instruction::PUSH1); |
|||
append(0); |
|||
append(eth::Instruction::SUB); |
|||
append(eth::Instruction::XOR); |
|||
break; |
|||
case Token::DELETE: // delete
|
|||
// a -> a xor a (= 0).
|
|||
// @todo this should also be an assignment
|
|||
// @todo semantics change for complex types
|
|||
append(eth::Instruction::DUP1); |
|||
append(eth::Instruction::XOR); |
|||
break; |
|||
case Token::INC: // ++ (pre- or postfix)
|
|||
// @todo this should also be an assignment
|
|||
if (_unaryOperation.isPrefixOperation()) |
|||
{ |
|||
append(eth::Instruction::PUSH1); |
|||
append(1); |
|||
append(eth::Instruction::ADD); |
|||
} |
|||
break; |
|||
case Token::DEC: // -- (pre- or postfix)
|
|||
// @todo this should also be an assignment
|
|||
if (_unaryOperation.isPrefixOperation()) |
|||
{ |
|||
append(eth::Instruction::PUSH1); |
|||
append(1); |
|||
append(eth::Instruction::SWAP1); //@todo avoid this
|
|||
append(eth::Instruction::SUB); |
|||
} |
|||
break; |
|||
case Token::ADD: // +
|
|||
// unary add, so basically no-op
|
|||
break; |
|||
case Token::SUB: // -
|
|||
append(eth::Instruction::NEG); |
|||
break; |
|||
default: |
|||
BOOST_ASSERT(false); // invalid operation
|
|||
} |
|||
} |
|||
|
|||
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
|
|||
BOOST_ASSERT(*leftExpression.getType() == *rightExpression.getType()); |
|||
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; |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(FunctionCall& _functionCall) |
|||
{ |
|||
if (_functionCall.isTypeConversion()) |
|||
{ |
|||
//@todo binary representation for all supported types (bool and int) is the same, so no-op
|
|||
// here for now.
|
|||
} |
|||
else |
|||
{ |
|||
//@todo
|
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(MemberAccess& _memberAccess) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(IndexAccess& _indexAccess) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Identifier& _identifier) |
|||
{ |
|||
|
|||
} |
|||
|
|||
void ExpressionCompiler::endVisit(Literal& _literal) |
|||
{ |
|||
switch (_literal.getType()->getCategory()) |
|||
{ |
|||
case Type::Category::INTEGER: |
|||
case Type::Category::BOOL: |
|||
{ |
|||
bytes value = _literal.getType()->literalToBigEndian(_literal); |
|||
BOOST_ASSERT(value.size() <= 32); |
|||
BOOST_ASSERT(!value.empty()); |
|||
append(static_cast<byte>(eth::Instruction::PUSH1) + static_cast<byte>(value.size() - 1)); |
|||
append(value); |
|||
break; |
|||
} |
|||
default: |
|||
BOOST_ASSERT(false); // @todo
|
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::cleanHigherOrderBitsIfNeeded(const Type& _typeOnStack, const Type& _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_ASSERT(!_typeOnStack.isExplicitlyConvertibleTo(_targetType)); |
|||
BOOST_ASSERT(false); // these types should not be convertible.
|
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation& _binaryOperation) |
|||
{ |
|||
Token::Value const op = _binaryOperation.getOperator(); |
|||
BOOST_ASSERT(op == Token::OR || op == Token::AND); |
|||
|
|||
_binaryOperation.getLeftExpression().accept(*this); |
|||
append(eth::Instruction::DUP1); |
|||
if (op == Token::AND) |
|||
append(eth::Instruction::NOT); |
|||
uint32_t endLabel = appendConditionalJump(); |
|||
_binaryOperation.getRightExpression().accept(*this); |
|||
appendLabel(endLabel); |
|||
} |
|||
|
|||
void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
if (_operator == Token::EQ || _operator == Token::NE) |
|||
{ |
|||
append(eth::Instruction::EQ); |
|||
if (_operator == Token::NE) |
|||
append(eth::Instruction::NOT); |
|||
} |
|||
else |
|||
{ |
|||
IntegerType const* type = dynamic_cast<IntegerType const*>(&_type); |
|||
BOOST_ASSERT(type != nullptr); |
|||
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: |
|||
append(isSigned ? eth::Instruction::SGT : eth::Instruction::GT); |
|||
append(eth::Instruction::NOT); |
|||
break; |
|||
case Token::LTE: |
|||
append(isSigned ? eth::Instruction::SLT : eth::Instruction::LT); |
|||
append(eth::Instruction::NOT); |
|||
break; |
|||
case Token::GT: |
|||
append(isSigned ? eth::Instruction::SLT : eth::Instruction::LT); |
|||
break; |
|||
case Token::LT: |
|||
append(isSigned ? eth::Instruction::SGT : eth::Instruction::GT); |
|||
break; |
|||
default: |
|||
BOOST_ASSERT(false); |
|||
} |
|||
} |
|||
} |
|||
|
|||
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_ASSERT(false); // unknown binary operator
|
|||
} |
|||
|
|||
void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Type const& _type) |
|||
{ |
|||
IntegerType const* type = dynamic_cast<IntegerType const*>(&_type); |
|||
BOOST_ASSERT(type != nullptr); |
|||
bool const isSigned = type->isSigned(); |
|||
|
|||
switch (_operator) |
|||
{ |
|||
case Token::ADD: |
|||
append(eth::Instruction::ADD); |
|||
break; |
|||
case Token::SUB: |
|||
append(eth::Instruction::SWAP1); |
|||
append(eth::Instruction::SUB); |
|||
break; |
|||
case Token::MUL: |
|||
append(eth::Instruction::MUL); |
|||
break; |
|||
case Token::DIV: |
|||
append(isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV); |
|||
break; |
|||
case Token::MOD: |
|||
append(isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD); |
|||
break; |
|||
default: |
|||
BOOST_ASSERT(false); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator) |
|||
{ |
|||
switch (_operator) |
|||
{ |
|||
case Token::BIT_OR: |
|||
append(eth::Instruction::OR); |
|||
break; |
|||
case Token::BIT_AND: |
|||
append(eth::Instruction::AND); |
|||
break; |
|||
case Token::BIT_XOR: |
|||
append(eth::Instruction::XOR); |
|||
break; |
|||
default: |
|||
BOOST_ASSERT(false); |
|||
} |
|||
} |
|||
|
|||
void ExpressionCompiler::appendShiftOperatorCode(Token::Value _operator) |
|||
{ |
|||
switch (_operator) |
|||
{ |
|||
case Token::SHL: |
|||
BOOST_ASSERT(false); //@todo
|
|||
break; |
|||
case Token::SAR: |
|||
BOOST_ASSERT(false); //@todo
|
|||
break; |
|||
default: |
|||
BOOST_ASSERT(false); |
|||
} |
|||
} |
|||
|
|||
uint32_t ExpressionCompiler::appendConditionalJump() |
|||
{ |
|||
uint32_t label = m_context.dispenseNewLabel(); |
|||
append(eth::Instruction::PUSH1); |
|||
appendLabelref(label); |
|||
append(eth::Instruction::JUMPI); |
|||
return label; |
|||
} |
|||
|
|||
void ExpressionCompiler::append(bytes const& _data) |
|||
{ |
|||
m_assemblyItems.reserve(m_assemblyItems.size() + _data.size()); |
|||
for (byte b: _data) |
|||
append(b); |
|||
} |
|||
|
|||
|
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,140 @@ |
|||
/*
|
|||
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. |
|||
*/ |
|||
|
|||
#include <libevmface/Instruction.h> |
|||
#include <libsolidity/ASTVisitor.h> |
|||
#include <libsolidity/Types.h> |
|||
#include <libsolidity/Token.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
/// A single item of compiled code that can be assembled to a single byte value in the final
|
|||
/// bytecode. Its main purpose is to inject jump labels and label references into the opcode stream,
|
|||
/// which can be resolved in the final step.
|
|||
class AssemblyItem |
|||
{ |
|||
public: |
|||
enum class Type |
|||
{ |
|||
CODE, //< m_data is opcode, m_label is empty.
|
|||
DATA, //< m_data is actual data, m_label is empty
|
|||
LABEL, //< m_data is JUMPDEST opcode, m_label is id of label
|
|||
LABELREF //< m_data is empty, m_label is id of label
|
|||
}; |
|||
|
|||
explicit AssemblyItem(eth::Instruction _instruction) : m_type(Type::CODE), m_data(byte(_instruction)) {} |
|||
explicit AssemblyItem(byte _data): m_type(Type::DATA), m_data(_data) {} |
|||
|
|||
/// Factory functions
|
|||
static AssemblyItem labelRef(uint32_t _label) { return AssemblyItem(Type::LABELREF, 0, _label); } |
|||
static AssemblyItem label(uint32_t _label) { return AssemblyItem(Type::LABEL, byte(eth::Instruction::JUMPDEST), _label); } |
|||
|
|||
Type getType() const { return m_type; } |
|||
byte getData() const { return m_data; } |
|||
uint32_t getLabel() const { return m_label; } |
|||
|
|||
private: |
|||
AssemblyItem(Type _type, byte _data, uint32_t _label): m_type(_type), m_data(_data), m_label(_label) {} |
|||
|
|||
Type m_type; |
|||
byte m_data; //< data to be written to the bytecode stream (or filled by a label if this is a LABELREF)
|
|||
uint32_t m_label; //< the id of a label either referenced or defined by this item
|
|||
}; |
|||
|
|||
using AssemblyItems = std::vector<AssemblyItem>; |
|||
|
|||
|
|||
/// Context to be shared by all units that compile the same contract. Its current usage only
|
|||
/// concerns dispensing unique jump label IDs and storing their actual positions in the bytecode
|
|||
/// stream.
|
|||
class CompilerContext |
|||
{ |
|||
public: |
|||
CompilerContext(): m_nextLabel(0) {} |
|||
uint32_t dispenseNewLabel() { return m_nextLabel++; } |
|||
void setLabelPosition(uint32_t _label, uint32_t _position); |
|||
uint32_t getLabelPosition(uint32_t _label) const; |
|||
|
|||
private: |
|||
uint32_t m_nextLabel; |
|||
|
|||
std::map<uint32_t, uint32_t> m_labelPositions; |
|||
}; |
|||
|
|||
/// 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: public ASTVisitor |
|||
{ |
|||
public: |
|||
ExpressionCompiler(CompilerContext& _compilerContext): m_context(_compilerContext) {} |
|||
|
|||
/// Compile the given expression and (re-)populate the assembly item list.
|
|||
void compile(Expression& _expression); |
|||
AssemblyItems const& getAssemblyItems() const { return m_assemblyItems; } |
|||
bytes getAssembledBytecode() const; |
|||
|
|||
/// Compile the given expression and return the assembly items right away.
|
|||
static AssemblyItems compileExpression(CompilerContext& _context, Expression& _expression); |
|||
|
|||
private: |
|||
virtual void endVisit(Assignment& _assignment) override; |
|||
virtual void endVisit(UnaryOperation& _unaryOperation) override; |
|||
virtual bool visit(BinaryOperation& _binaryOperation) override; |
|||
virtual void endVisit(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; |
|||
|
|||
/// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type.
|
|||
void cleanHigherOrderBitsIfNeeded(Type const& _typeOnStack, Type const& _targetType); |
|||
|
|||
/// 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); |
|||
/// @}
|
|||
|
|||
/// Appends a JUMPI instruction to a new label and returns the label
|
|||
uint32_t appendConditionalJump(); |
|||
|
|||
/// Append elements to the current instruction list.
|
|||
void append(eth::Instruction const& _instruction) { m_assemblyItems.push_back(AssemblyItem(_instruction)); } |
|||
void append(byte _value) { m_assemblyItems.push_back(AssemblyItem(_value)); } |
|||
void append(bytes const& _data); |
|||
void appendLabelref(byte _label) { m_assemblyItems.push_back(AssemblyItem::labelRef(_label)); } |
|||
void appendLabel(byte _label) { m_assemblyItems.push_back(AssemblyItem::label(_label)); } |
|||
|
|||
AssemblyItems m_assemblyItems; |
|||
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 name and type resolution of the solidity parser. |
|||
*/ |
|||
|
|||
#include <string> |
|||
|
|||
#include <libdevcore/Log.h> |
|||
#include <libsolidity/Scanner.h> |
|||
#include <libsolidity/Parser.h> |
|||
#include <libsolidity/NameAndTypeResolver.h> |
|||
#include <libsolidity/Compiler.h> |
|||
#include <libsolidity/AST.h> |
|||
#include <boost/test/unit_test.hpp> |
|||
|
|||
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; |
|||
}; |
|||
|
|||
bytes compileFirstExpression(const std::string& _sourceCode) |
|||
{ |
|||
Parser parser; |
|||
ASTPointer<ContractDefinition> contract; |
|||
BOOST_REQUIRE_NO_THROW(contract = parser.parse(std::make_shared<Scanner>(CharStream(_sourceCode)))); |
|||
NameAndTypeResolver resolver; |
|||
BOOST_REQUIRE_NO_THROW(resolver.resolveNamesAndTypes(*contract)); |
|||
FirstExpressionExtractor extractor(*contract); |
|||
BOOST_REQUIRE(extractor.getExpression() != nullptr); |
|||
|
|||
CompilerContext context; |
|||
ExpressionCompiler compiler(context); |
|||
compiler.compile(*extractor.getExpression()); |
|||
bytes instructions = compiler.getAssembledBytecode(); |
|||
// debug
|
|||
//std::cout << eth::disassemble(instructions) << std::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::NOT)}); |
|||
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::NOT), // 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::PUSH1), 0x2, |
|||
byte(eth::Instruction::PUSH1), 0x9, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::NOT), // after this we have 2 != 9
|
|||
byte(eth::Instruction::JUMPDEST), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::NOT)}); |
|||
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::MOD), |
|||
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), 0x1, |
|||
byte(eth::Instruction::ADD), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::SWAP1), |
|||
byte(eth::Instruction::SUB), |
|||
byte(eth::Instruction::NEG), |
|||
byte(eth::Instruction::PUSH1), 0x1, |
|||
byte(eth::Instruction::PUSH1), 0x0, |
|||
byte(eth::Instruction::SUB), |
|||
byte(eth::Instruction::XOR), // bitwise not
|
|||
byte(eth::Instruction::PUSH1), 0x2, |
|||
byte(eth::Instruction::EQ), |
|||
byte(eth::Instruction::NOT)}); |
|||
BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
} |
|||
} |
|||
} // end namespaces
|
|||
|
|||
Loading…
Reference in new issue