cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Code generation (missing external access and source locations).

Browse Source
This commit is contained in:
chriseth 2016-03-01 22:56:39 +01:00
parent 949b00ed59
commit f049430723
22 changed files with 866 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
libsolidity/analysis/ReferencesResolver.cpp
View File

@ -25,6 +25,8 @@
#include <libsolidity/analysis/NameAndTypeResolver.h>
#include <libsolidity/interface/Exceptions.h>
#include <libsolidity/analysis/ConstantEvaluator.h>
#include <libsolidity/inlineasm/AsmCodeGen.h>
#include <libsolidity/inlineasm/AsmData.h>
using namespace std;
using namespace dev;
@ -112,6 +114,26 @@ void ReferencesResolver::endVisit(ArrayTypeName const& _typeName)
_typeName.annotation().type = make_shared<ArrayType>(DataLocation::Storage, baseType);
}
bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
{
// We need to perform a full code generation pass here as inline assembly does not distinguish
// reference resolution and code generation.
// Errors created in this stage are completely ignored because we do not yet know
// the type and size of external identifiers, which would result in false errors.
ErrorList errorsIgnored;
assembly::CodeGenerator codeGen(_inlineAssembly.operations(), errorsIgnored);
codeGen.typeCheck([&](assembly::Identifier const& _identifier, eth::Assembly&, assembly::CodeGenerator::IdentifierContext) {
auto declarations = m_resolver.nameFromCurrentScope(_identifier.name);
if (declarations.size() != 1)
return false;
_inlineAssembly.annotation().externalReferences[&_identifier] = declarations.front();
// At this stage we neither know the code to generate nor the stack size of the identifier,
// so we do not modify assembly.
return true;
});
return false;
}
bool ReferencesResolver::visit(Return const& _return)
{
_return.annotation().functionReturnParameters = m_returnParameters;

1
libsolidity/analysis/ReferencesResolver.h
View File

@ -64,6 +64,7 @@ private:
virtual void endVisit(UserDefinedTypeName const& _typeName) override;
virtual void endVisit(Mapping const& _typeName) override;
virtual void endVisit(ArrayTypeName const& _typeName) override;
virtual bool visit(InlineAssembly const& _inlineAssembly) override;
virtual bool visit(Return const& _return) override;
virtual void endVisit(VariableDeclaration const& _variable) override;

57
libsolidity/analysis/TypeChecker.cpp
View File

@ -24,6 +24,8 @@
#include <memory>
#include <boost/range/adaptor/reversed.hpp>
#include <libsolidity/ast/AST.h>
#include <libevmasm/Assembly.h> // needed for inline assembly
#include <libsolidity/inlineasm/AsmCodeGen.h>
using namespace std;
using namespace dev;
@ -547,6 +549,61 @@ bool TypeChecker::visit(EventDefinition const& _eventDef)
return false;
}
bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
{
// Inline assembly does not have its own type-checking phase, so we just run the
// code-generator and see whether it produces any errors.
// External references have already been resolved in a prior stage and stored in the annotation.
assembly::CodeGenerator codeGen(_inlineAssembly.operations(), m_errors);
codeGen.typeCheck([&](assembly::Identifier const& _identifier, eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierContext _context) {
auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
if (ref == _inlineAssembly.annotation().externalReferences.end())
return false;
Declaration const* declaration = ref->second;
solAssert(!!declaration, "");
if (_context == assembly::CodeGenerator::IdentifierContext::RValue)
{
solAssert(!!declaration->type(), "Type of declaration required but not yet determined.");
unsigned pushes = 0;
if (dynamic_cast<FunctionDefinition const*>(declaration))
pushes = 1;
else if (auto var = dynamic_cast<VariableDeclaration const*>(declaration))
{
if (var->isConstant())
fatalTypeError(SourceLocation(), "Constant variables not yet implemented for inline assembly.");
if (var->isLocalVariable())
pushes = var->type()->sizeOnStack();
else if (var->type()->isValueType())
pushes = 1;
else
pushes = 2; // slot number, intra slot offset
}
else if (auto contract = dynamic_cast<ContractDefinition const*>(declaration))
{
if (!contract->isLibrary())
return false;
pushes = 1;
}
for (unsigned i = 0; i < pushes; ++i)
_assembly.append(u256(0)); // just to verify the stack height
}
else
{
// lvalue context
if (auto varDecl = dynamic_cast<VariableDeclaration const*>(declaration))
{
if (!varDecl->isLocalVariable())
return false; // only local variables are inline-assemlby lvalues
for (unsigned i = 0; i < declaration->type()->sizeOnStack(); ++i)
_assembly.append(eth::Instruction::POP); // remove value just to verify the stack height
}
else
return false;
}
return true;
});
return false;
}
bool TypeChecker::visit(IfStatement const& _ifStatement)
{

1
libsolidity/analysis/TypeChecker.h
View File

@ -84,6 +84,7 @@ private:
/// case this is a base constructor call.
void visitManually(ModifierInvocation const& _modifier, std::vector<ContractDefinition const*> const& _bases);
virtual bool visit(EventDefinition const& _eventDef) override;
virtual bool visit(InlineAssembly const& _inlineAssembly) override;
virtual bool visit(IfStatement const& _ifStatement) override;
virtual bool visit(WhileStatement const& _whileStatement) override;
virtual bool visit(ForStatement const& _forStatement) override;

7
libsolidity/ast/AST.cpp
View File

@ -363,6 +363,13 @@ StatementAnnotation& Statement::annotation() const
return static_cast<StatementAnnotation&>(*m_annotation);
}
InlineAssemblyAnnotation& InlineAssembly::annotation() const
{
if (!m_annotation)
m_annotation = new InlineAssemblyAnnotation();
return static_cast<InlineAssemblyAnnotation&>(*m_annotation);
}
ReturnAnnotation& Return::annotation() const
{
if (!m_annotation)

15
libsolidity/ast/AST.h
View File

@ -855,8 +855,11 @@ public:
virtual StatementAnnotation& annotation() const override;
};
// Forward-declaration to InlineAssembly.h
class AsmData;
namespace assembly
{
// Forward-declaration to AsmData.h
struct Block;
}
/**
* Inline assembly.
@ -867,16 +870,18 @@ public:
InlineAssembly(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString,
std::shared_ptr<AsmData> const& _operations
std::shared_ptr<assembly::Block> const& _operations
):
Statement(_location, _docString), m_operations(_operations) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
AsmData const& operations() const { return *m_operations; }
assembly::Block const& operations() const { return *m_operations; }
virtual InlineAssemblyAnnotation& annotation() const override;
private:
std::shared_ptr<AsmData> m_operations;
std::shared_ptr<assembly::Block> m_operations;
};
/**

11
libsolidity/ast/ASTAnnotations.h
View File

@ -110,6 +110,17 @@ struct StatementAnnotation: ASTAnnotation, DocumentedAnnotation
{
};
namespace assembly
{
struct Identifier; // forward
}
struct InlineAssemblyAnnotation: StatementAnnotation
{
/// Mapping containing resolved references to external identifiers.
std::map<assembly::Identifier const*, Declaration const*> externalReferences;
};
struct ReturnAnnotation: StatementAnnotation
{
/// Reference to the return parameters of the function.

86
libsolidity/codegen/Compiler.cpp
View File

@ -26,6 +26,7 @@
#include <libevmcore/Instruction.h>
#include <libethcore/ChainOperationParams.h>
#include <libevmasm/Assembly.h>
#include <libsolidity/inlineasm/AsmCodeGen.h>
#include <libsolidity/ast/AST.h>
#include <libsolidity/codegen/ExpressionCompiler.h>
#include <libsolidity/codegen/CompilerUtils.h>
@ -497,6 +498,91 @@ bool Compiler::visit(FunctionDefinition const& _function)
return false;
}
bool Compiler::visit(InlineAssembly const& _inlineAssembly)
{
ErrorList errors;
assembly::CodeGenerator codeGen(_inlineAssembly.operations(), errors);
int startStackHeight = m_context.stackHeight();
m_context.appendInlineAssembly(codeGen.assemble(
[&](assembly::Identifier const& _identifier, eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierContext _context) {
auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
if (ref == _inlineAssembly.annotation().externalReferences.end())
return false;
Declaration const* decl = ref->second;
solAssert(!!decl, "");
if (_context == assembly::CodeGenerator::IdentifierContext::RValue)
{
solAssert(!!decl->type(), "Type of declaration required but not yet determined.");
if (/*FunctionDefinition const* functionDef = */dynamic_cast<FunctionDefinition const*>(decl))
{
solAssert(false, "Referencing local functions in inline assembly not yet implemented.");
// This does not work directly, because the label does not exist in _assembly
// (it is a fresh assembly object).
// _assembly.append(m_context.virtualFunctionEntryLabel(*functionDef).pushTag());
}
else if (auto variable = dynamic_cast<VariableDeclaration const*>(decl))
{
solAssert(!variable->isConstant(), "");
if (m_context.isLocalVariable(variable))
{
int stackDiff = _assembly.deposit() + startStackHeight - m_context.baseStackOffsetOfVariable(*variable);
if (stackDiff < 1 || stackDiff > 16)
BOOST_THROW_EXCEPTION(
CompilerError() <<
errinfo_comment("Stack too deep, try removing local variables.")
);
for (unsigned i = 0; i < variable->type()->sizeOnStack(); ++i)
_assembly.append(eth::dupInstruction(stackDiff));
}
else
{
solAssert(m_context.isStateVariable(variable), "Invalid variable type.");
auto const& location = m_context.storageLocationOfVariable(*variable);
if (!variable->type()->isValueType())
{
solAssert(location.second == 0, "Intra-slot offest assumed to be zero.");
_assembly.append(location.first);
}
else
{
_assembly.append(location.first);
_assembly.append(u256(location.second));
}
}
}
else if (auto contract = dynamic_cast<ContractDefinition const*>(decl))
{
solAssert(contract->isLibrary(), "");
_assembly.appendLibraryAddress(contract->name());
}
else
solAssert(false, "Invalid declaration type.");
} else {
// lvalue context
auto variable = dynamic_cast<VariableDeclaration const*>(decl);
solAssert(
!!variable || !m_context.isLocalVariable(variable),
"Can only assign to stack variables in inline assembly."
);
unsigned size = variable->type()->sizeOnStack();
int stackDiff = _assembly.deposit() + startStackHeight - m_context.baseStackOffsetOfVariable(*variable) - size;
if (stackDiff > 16 || stackDiff < 1)
BOOST_THROW_EXCEPTION(
CompilerError() <<
errinfo_comment("Stack too deep, try removing local variables.")
);
for (unsigned i = 0; i < size; ++i) {
_assembly.append(eth::swapInstruction(stackDiff));
_assembly.append(eth::Instruction::POP);
}
}
return true;
}
));
solAssert(errors.empty(), "Code generation for inline assembly with errors requested.");
return false;
}
bool Compiler::visit(IfStatement const& _ifStatement)
{
StackHeightChecker checker(m_context);

1
libsolidity/codegen/Compiler.h
View File

@ -94,6 +94,7 @@ private:
virtual bool visit(VariableDeclaration const& _variableDeclaration) override;
virtual bool visit(FunctionDefinition const& _function) override;
virtual bool visit(InlineAssembly const& _inlineAssembly) override;
virtual bool visit(IfStatement const& _ifStatement) override;
virtual bool visit(WhileStatement const& _whileStatement) override;
virtual bool visit(ForStatement const& _forStatement) override;

2
libsolidity/codegen/CompilerContext.h
View File

@ -109,6 +109,8 @@ public:
/// 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); }
/// Appends the given code (used by inline assembly) ignoring any stack height changes.
void appendInlineAssembly(eth::Assembly const& _assembly) { int deposit = m_asm.deposit(); m_asm.append(_assembly); m_asm.setDeposit(deposit); }
/// Pushes the size of the final program
void appendProgramSize() { return m_asm.appendProgramSize(); }
/// Adds data to the data section, pushes a reference to the stack

263
libsolidity/inlineasm/AsmCodeGen.cpp Normal file
View File

@ -0,0 +1,263 @@
/*
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 2016
* Code-generating part of inline assembly.
*/
#include <libsolidity/inlineasm/AsmCodeGen.h>
#include <memory>
#include <functional>
#include <libevmasm/Assembly.h>
#include <libevmasm/SourceLocation.h>
#include <libsolidity/inlineasm/AsmParser.h>
#include <libsolidity/inlineasm/AsmData.h>
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace dev::solidity::assembly;
struct GeneratorState
{
explicit GeneratorState(ErrorList& _errors): errors(_errors) {}
void addError(Error::Type _type, std::string const& _description, SourceLocation const& _location = SourceLocation())
{
auto err = make_shared<Error>(_type);
if (!_location.isEmpty())
*err << errinfo_sourceLocation(_location);
*err << errinfo_comment(_description);
errors.push_back(err);
}
int const* findVariable(string const& _variableName) const
{
auto localVariable = find_if(
variables.rbegin(),
variables.rend(),
[&](pair<string, int> const& _var) { return _var.first == _variableName; }
);
return localVariable != variables.rend() ? &localVariable->second : nullptr;
}
eth::AssemblyItem const* findLabel(string const& _labelName) const
{
auto label = find_if(
labels.begin(),
labels.end(),
[&](pair<string, eth::AssemblyItem> const& _label) { return _label.first == _labelName; }
);
return label != labels.end() ? &label->second : nullptr;
}
eth::Assembly assembly;
map<string, eth::AssemblyItem> labels;
vector<pair<string, int>> variables; ///< name plus stack height
ErrorList& errors;
};
/**
* Scans the inline assembly data for labels, creates tags in the assembly and searches for
* duplicate labels.
*/
class LabelOrganizer: public boost::static_visitor<>
{
public:
LabelOrganizer(GeneratorState& _state): m_state(_state) {}
template <class T>
void operator()(T const& /*_item*/) { }
void operator()(Label const& _item)
{
if (m_state.labels.count(_item.name))
//@TODO location and secondary location
m_state.addError(Error::Type::DeclarationError, "Label " + _item.name + " declared twice.");
m_state.labels.insert(make_pair(_item.name, m_state.assembly.newTag()));
}
void operator()(assembly::Block const& _block)
{
std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
}
private:
GeneratorState& m_state;
};
class CodeTransform: public boost::static_visitor<>
{
public:
/// Create the code transformer which appends assembly to _state.assembly when called
/// with parsed assembly data.
/// @param _identifierAccess used to resolve identifiers external to the inline assembly
explicit CodeTransform(
GeneratorState& _state,
assembly::CodeGenerator::IdentifierAccess const& _identifierAccess = assembly::CodeGenerator::IdentifierAccess()
):
m_state(_state)
{
if (_identifierAccess)
m_identifierAccess = _identifierAccess;
else
m_identifierAccess = [](assembly::Identifier const&, eth::Assembly&, CodeGenerator::IdentifierContext) { return false; };
}
void operator()(Instruction const& _instruction)
{
m_state.assembly.append(_instruction.instruction);
}
void operator()(assembly::Literal const& _literal)
{
if (_literal.isNumber)
m_state.assembly.append(u256(_literal.value));
else if (_literal.value.size() > 32)
m_state.addError(
Error::Type::TypeError,
"String literal too long (" + boost::lexical_cast<string>(_literal.value.size()) + " > 32)"
);
else
m_state.assembly.append(_literal.value);
}
void operator()(assembly::Identifier const& _identifier)
{
// First search local variables, then labels, then externals.
if (int const* stackHeight = m_state.findVariable(_identifier.name))
{
int heightDiff = m_state.assembly.deposit() - *stackHeight;
if (heightDiff <= 0 || heightDiff > 16)
//@TODO location
m_state.addError(
Error::Type::TypeError,
"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")"
);
else
m_state.assembly.append(eth::dupInstruction(heightDiff));
return;
}
else if (eth::AssemblyItem const* label = m_state.findLabel(_identifier.name))
m_state.assembly.append(label->pushTag());
else if (!m_identifierAccess(_identifier, m_state.assembly, CodeGenerator::IdentifierContext::RValue))
m_state.addError(
Error::Type::DeclarationError,
"Identifier \"" + string(_identifier.name) + "\" not found or not unique"
);
}
void operator()(FunctionalInstruction const& _instr)
{
for (auto it = _instr.arguments.rbegin(); it != _instr.arguments.rend(); ++it)
{
int height = m_state.assembly.deposit();
boost::apply_visitor(*this, *it);
expectDeposit(1, height);
}
(*this)(_instr.instruction);
}
void operator()(Label const& _label)
{
m_state.assembly.append(m_state.labels.at(_label.name));
}
void operator()(assembly::Assignment const& _assignment)
{
generateAssignment(_assignment.variableName);
}
void operator()(FunctionalAssignment const& _assignment)
{
int height = m_state.assembly.deposit();
boost::apply_visitor(*this, *_assignment.value);
expectDeposit(1, height);
generateAssignment(_assignment.variableName);
}
void operator()(assembly::VariableDeclaration const& _varDecl)
{
int height = m_state.assembly.deposit();
boost::apply_visitor(*this, *_varDecl.value);
expectDeposit(1, height);
m_state.variables.push_back(make_pair(_varDecl.name, height));
}
void operator()(assembly::Block const& _block)
{
size_t numVariables = m_state.variables.size();
std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
// pop variables
//@TODO check height before and after
while (m_state.variables.size() > numVariables)
{
m_state.assembly.append(eth::Instruction::POP);
m_state.variables.pop_back();
}
}
private:
void generateAssignment(assembly::Identifier const& _variableName)
{
if (int const* stackHeight = m_state.findVariable(_variableName.name))
{
int heightDiff = m_state.assembly.deposit() - *stackHeight - 1;
if (heightDiff <= 0 || heightDiff > 16)
//@TODO location
m_state.addError(
Error::Type::TypeError,
"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")"
);
else
{
m_state.assembly.append(eth::swapInstruction(heightDiff));
m_state.assembly.append(eth::Instruction::POP);
}
return;
}
else if (!m_identifierAccess(_variableName, m_state.assembly, CodeGenerator::IdentifierContext::LValue))
m_state.addError(
Error::Type::DeclarationError,
"Identifier \"" + string(_variableName.name) + "\" not found, not unique or not lvalue."
);
}
void expectDeposit(int _deposit, int _oldHeight)
{
if (m_state.assembly.deposit() != _oldHeight + 1)
//@TODO location
m_state.addError(Error::Type::TypeError,
"Expected instruction(s) to deposit " +
boost::lexical_cast<string>(_deposit) +
" item(s) to the stack, but did deposit " +
boost::lexical_cast<string>(m_state.assembly.deposit() - _oldHeight) +
" item(s)."
);
}
GeneratorState& m_state;
assembly::CodeGenerator::IdentifierAccess m_identifierAccess;
};
bool assembly::CodeGenerator::typeCheck(assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
{
size_t initialErrorLen = m_errors.size();
GeneratorState state(m_errors);
(LabelOrganizer(state))(m_parsedData);
(CodeTransform(state, _identifierAccess))(m_parsedData);
return m_errors.size() == initialErrorLen;
}
eth::Assembly assembly::CodeGenerator::assemble(assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
{
GeneratorState state(m_errors);
(LabelOrganizer(state))(m_parsedData);
(CodeTransform(state, _identifierAccess))(m_parsedData);
return state.assembly;
}

66
libsolidity/inlineasm/AsmCodeGen.h Normal file
View File

@ -0,0 +1,66 @@
/*
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 2016
* Code-generating part of inline assembly.
*/
#pragma once
#include <functional>
#include <libsolidity/interface/Exceptions.h>
namespace dev
{
namespace eth
{
class Assembly;
}
namespace solidity
{
namespace assembly
{
struct Block;
struct Identifier;
class CodeGenerator
{
public:
enum class IdentifierContext { LValue, RValue };
/// Function type that is called for external identifiers. Such a function should search for
/// the identifier and append appropriate assembly items to the assembly. If in lvalue context,
/// the value to assign is assumed to be on the stack and an assignment is to be performed.
/// If in rvalue context, the function is assumed to append instructions to
/// push the value of the identifier onto the stack. On error, the function should return false.
using IdentifierAccess = std::function<bool(assembly::Identifier const&, eth::Assembly&, IdentifierContext)>;
CodeGenerator( Block const& _parsedData, ErrorList& _errors):
m_parsedData(_parsedData), m_errors(_errors) {}
/// Performs type checks and @returns false on error.
/// Actually runs the full code generation but discards the result.
bool typeCheck(IdentifierAccess const& _identifierAccess = IdentifierAccess());
/// Performs code generation and @returns the result.
eth::Assembly assemble(IdentifierAccess const& _identifierAccess = IdentifierAccess());
private:
Block const& m_parsedData;
ErrorList& m_errors;
};
}
}
}

60
libsolidity/inlineasm/AsmData.h
View File

@ -29,42 +29,36 @@ namespace dev
{
namespace solidity
{
class AsmData
namespace assembly
{
public:
/// Direct EVM instruction (except PUSHi and JUMPDEST)
struct Instruction { eth::Instruction instruction; };
/// Literal number or string (up to 32 bytes)
struct Literal { bool isNumber; std::string value; };
/// External / internal identifier or label reference
struct Identifier { std::string name; };
struct FunctionalInstruction;
/// Jump label ("name:")
struct Label { std::string name; };
/// Assignemnt (":= x", moves stack top into x, potentially multiple slots)
struct Assignment { Identifier variableName; };
struct FunctionalAssignment;
struct VariableDeclaration;
struct Block;
using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionalInstruction, VariableDeclaration, Block>;
/// Functional assignment ("x := mload(20)", expects push-1-expression on the right hand
/// side and requires x to occupy exactly one stack slot.
struct FunctionalAssignment { Identifier variableName; std::shared_ptr<Statement> value; };
/// Functional instruction, e.g. "mul(mload(20), add(2, x))"
struct FunctionalInstruction { Instruction instruction; std::vector<Statement> arguments; };
/// Block-scope variable declaration ("let x := mload(20)"), non-hoisted
struct VariableDeclaration { std::string name; std::shared_ptr<Statement> value; };
/// Block that creates a scope (frees declared stack variables)
struct Block { std::vector<Statement> statements; };
AsmData(Block&& _statements): m_statements(_statements) {}
/// What follows are the AST nodes for assembly.
Block const& statements() const { return m_statements; }
private:
Block m_statements;
};
/// Direct EVM instruction (except PUSHi and JUMPDEST)
struct Instruction { eth::Instruction instruction; };
/// Literal number or string (up to 32 bytes)
struct Literal { bool isNumber; std::string value; };
/// External / internal identifier or label reference
struct Identifier { std::string name; };
struct FunctionalInstruction;
/// Jump label ("name:")
struct Label { std::string name; };
/// Assignemnt (":= x", moves stack top into x, potentially multiple slots)
struct Assignment { Identifier variableName; };
struct FunctionalAssignment;
struct VariableDeclaration;
struct Block;
using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionalInstruction, VariableDeclaration, Block>;
/// Functional assignment ("x := mload(20)", expects push-1-expression on the right hand
/// side and requires x to occupy exactly one stack slot.
struct FunctionalAssignment { Identifier variableName; std::shared_ptr<Statement> value; };
/// Functional instruction, e.g. "mul(mload(20), add(2, x))"
struct FunctionalInstruction { Instruction instruction; std::vector<Statement> arguments; };
/// Block-scope variable declaration ("let x := mload(20)"), non-hoisted
struct VariableDeclaration { std::string name; std::shared_ptr<Statement> value; };
/// Block that creates a scope (frees declared stack variables)
struct Block { std::vector<Statement> statements; };
}
}
}

67
libsolidity/inlineasm/AsmParser.cpp
View File

@ -29,13 +29,14 @@
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace dev::solidity::assembly;
shared_ptr<AsmData> InlineAssemblyParser::parse(std::shared_ptr<Scanner> const& _scanner)
shared_ptr<assembly::Block> Parser::parse(std::shared_ptr<Scanner> const& _scanner)
{
try
{
m_scanner = _scanner;
return make_shared<AsmData>(parseBlock());
return make_shared<assembly::Block>(parseBlock());
}
catch (FatalError const&)
{
@ -45,17 +46,17 @@ shared_ptr<AsmData> InlineAssemblyParser::parse(std::shared_ptr<Scanner> const&
return nullptr;
}
AsmData::Block InlineAssemblyParser::parseBlock()
assembly::Block Parser::parseBlock()
{
expectToken(Token::LBrace);
AsmData::Block block;
Block block;
while (m_scanner->currentToken() != Token::RBrace)
block.statements.emplace_back(parseStatement());
m_scanner->next();
return block;
}
AsmData::Statement InlineAssemblyParser::parseStatement()
assembly::Statement Parser::parseStatement()
{
switch (m_scanner->currentToken())
{
@ -69,8 +70,9 @@ AsmData::Statement InlineAssemblyParser::parseStatement()
expectToken(Token::Colon);
string name = m_scanner->currentLiteral();
expectToken(Token::Identifier);
return AsmData::Assignment{AsmData::Identifier{name}};
return assembly::Assignment{assembly::Identifier{name}};
}
case Token::Return: // opcode
default:
break;
}
@ -78,28 +80,28 @@ AsmData::Statement InlineAssemblyParser::parseStatement()
// Simple instruction (might turn into functional),
// literal,
// identifier (might turn into label or functional assignment)
AsmData::Statement statement(parseElementaryOperation());
Statement statement(parseElementaryOperation());
switch (m_scanner->currentToken())
{
case Token::LParen:
return parseFunctionalInstruction(statement);
case Token::Colon:
{
if (statement.type() != typeid(AsmData::Identifier))
if (statement.type() != typeid(assembly::Identifier))
fatalParserError("Label name / variable name must precede \":\".");
string const& name = boost::get<AsmData::Identifier>(statement).name;
string const& name = boost::get<assembly::Identifier>(statement).name;
m_scanner->next();
if (m_scanner->currentToken() == Token::Assign)
{
// functional assignment
m_scanner->next();
unique_ptr<AsmData::Statement> value;
value.reset(new AsmData::Statement(parseExpression()));
return AsmData::FunctionalAssignment{{move(name)}, move(value)};
unique_ptr<Statement> value;
value.reset(new Statement(parseExpression()));
return FunctionalAssignment{{std::move(name)}, std::move(value)};
}
else
// label
return AsmData::Label{name};
return Label{name};
}
default:
break;
@ -107,16 +109,16 @@ AsmData::Statement InlineAssemblyParser::parseStatement()
return statement;
}
AsmData::Statement InlineAssemblyParser::parseExpression()
assembly::Statement Parser::parseExpression()
{
AsmData::Statement operation = parseElementaryOperation(true);
Statement operation = parseElementaryOperation(true);
if (m_scanner->currentToken() == Token::LParen)
return parseFunctionalInstruction(operation);
else
return operation;
}
AsmData::Statement InlineAssemblyParser::parseElementaryOperation(bool _onlySinglePusher)
assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
{
// Allowed instructions, lowercase names.
static map<string, eth::Instruction> s_instructions;
@ -129,6 +131,8 @@ AsmData::Statement InlineAssemblyParser::parseElementaryOperation(bool _onlySing
)
continue;
string name = instruction.first;
if (instruction.second == eth::Instruction::SUICIDE)
name = "selfdestruct";
transform(name.begin(), name.end(), name.begin(), [](unsigned char _c) { return tolower(_c); });
s_instructions[name] = instruction.second;
}
@ -138,8 +142,13 @@ AsmData::Statement InlineAssemblyParser::parseElementaryOperation(bool _onlySing
switch (m_scanner->currentToken())
{
case Token::Identifier:
case Token::Return:
{
string literal = m_scanner->currentLiteral();
string literal;
if (m_scanner->currentToken() == Token::Return)
literal = "return";
else
literal = m_scanner->currentLiteral();
// first search the set of instructions.
if (s_instructions.count(literal))
{
@ -151,17 +160,17 @@ AsmData::Statement InlineAssemblyParser::parseElementaryOperation(bool _onlySing
fatalParserError("Instruction " + info.name + " not allowed in this context.");
}
m_scanner->next();
return AsmData::Instruction{instr};
return Instruction{instr};
}
else
m_scanner->next();
return AsmData::Identifier{literal};
return Identifier{literal};
break;
}
case Token::StringLiteral:
case Token::Number:
{
AsmData::Literal literal{
Literal literal{
m_scanner->currentToken() == Token::Number,
m_scanner->currentLiteral()
};
@ -175,23 +184,23 @@ AsmData::Statement InlineAssemblyParser::parseElementaryOperation(bool _onlySing
return {};
}
AsmData::VariableDeclaration InlineAssemblyParser::parseVariableDeclaration()
assembly::VariableDeclaration Parser::parseVariableDeclaration()
{
expectToken(Token::Let);
string name = m_scanner->currentLiteral();
expectToken(Token::Identifier);
expectToken(Token::Colon);
expectToken(Token::Assign);
unique_ptr<AsmData::Statement> value;
value.reset(new AsmData::Statement(parseExpression()));
return AsmData::VariableDeclaration{name, move(value)};
unique_ptr<Statement> value;
value.reset(new Statement(parseExpression()));
return VariableDeclaration{name, std::move(value)};
}
AsmData::FunctionalInstruction InlineAssemblyParser::parseFunctionalInstruction(AsmData::Statement const& _instruction)
FunctionalInstruction Parser::parseFunctionalInstruction(assembly::Statement const& _instruction)
{
if (_instruction.type() != typeid(AsmData::Instruction))
if (_instruction.type() != typeid(Instruction))
fatalParserError("Assembly instruction required in front of \"(\")");
eth::Instruction instr = boost::get<AsmData::Instruction>(_instruction).instruction;
eth::Instruction instr = boost::get<Instruction>(_instruction).instruction;
eth::InstructionInfo instrInfo = eth::instructionInfo(instr);
if (eth::Instruction::DUP1 <= instr && instr <= eth::Instruction::DUP16)
fatalParserError("DUPi instructions not allowed for functional notation");
@ -199,7 +208,7 @@ AsmData::FunctionalInstruction InlineAssemblyParser::parseFunctionalInstruction(
fatalParserError("SWAPi instructions not allowed for functional notation");
expectToken(Token::LParen);
vector<AsmData::Statement> arguments;
vector<Statement> arguments;
unsigned args = unsigned(instrInfo.args);
for (unsigned i = 0; i < args; ++i)
{
@ -208,5 +217,5 @@ AsmData::FunctionalInstruction InlineAssemblyParser::parseFunctionalInstruction(
expectToken(Token::Comma);
}
expectToken(Token::RParen);
return AsmData::FunctionalInstruction{{instr}, move(arguments)};
return FunctionalInstruction{{instr}, std::move(arguments)};
}

21
libsolidity/inlineasm/AsmParser.h
View File

@ -31,25 +31,28 @@ namespace dev
{
namespace solidity
{
namespace assembly
{
class InlineAssemblyParser: public ParserBase
class Parser: public ParserBase
{
public:
InlineAssemblyParser(ErrorList& _errors): ParserBase(_errors) {}
Parser(ErrorList& _errors): ParserBase(_errors) {}
/// Parses an inline assembly block starting with `{` and ending with `}`.
/// @returns an empty shared pointer on error.
std::shared_ptr<AsmData> parse(std::shared_ptr<Scanner> const& _scanner);
std::shared_ptr<Block> parse(std::shared_ptr<Scanner> const& _scanner);
protected:
AsmData::Block parseBlock();
AsmData::Statement parseStatement();
Block parseBlock();
Statement parseStatement();
/// Parses a functional expression that has to push exactly one stack element
AsmData::Statement parseExpression();
AsmData::Statement parseElementaryOperation(bool _onlySinglePusher = false);
AsmData::VariableDeclaration parseVariableDeclaration();
AsmData::FunctionalInstruction parseFunctionalInstruction(AsmData::Statement const& _instruction);
Statement parseExpression();
Statement parseElementaryOperation(bool _onlySinglePusher = false);
VariableDeclaration parseVariableDeclaration();
FunctionalInstruction parseFunctionalInstruction(Statement const& _instruction);
};
}
}
}

47
libsolidity/inlineasm/AsmStack.cpp Normal file
View File

@ -0,0 +1,47 @@
/*
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 2016
* Full-stack Solidity inline assember.
*/
#include <libsolidity/inlineasm/AsmStack.h>
#include <memory>
#include <libevmasm/Assembly.h>
#include <libevmasm/SourceLocation.h>
#include <libsolidity/inlineasm/AsmParser.h>
#include <libsolidity/inlineasm/AsmCodeGen.h>
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace dev::solidity::assembly;
bool InlineAssemblyStack::parse(const std::shared_ptr<Scanner>& _scanner)
{
Parser parser(m_errors);
m_asmBlock = parser.parse(_scanner);
return !!m_asmBlock;
}
eth::Assembly InlineAssemblyStack::assemble()
{
CodeGenerator codeGen(*m_asmBlock, m_errors);
return codeGen.assemble();
}

59
libsolidity/inlineasm/AsmStack.h Normal file
View File

@ -0,0 +1,59 @@
/*
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 2016
* Full-stack Solidity inline assember.
*/
#pragma once
#include <string>
#include <functional>
#include <libsolidity/interface/Exceptions.h>
namespace dev
{
namespace eth
{
class Assembly;
}
namespace solidity
{
class Scanner;
namespace assembly
{
struct Block;
class InlineAssemblyStack
{
public:
/// Parse the given inline assembly chunk starting with `{` and ending with the corresponding `}`.
/// @return false or error.
bool parse(std::shared_ptr<Scanner> const& _scanner);
eth::Assembly assemble();
ErrorList const& errors() const { return m_errors; }
private:
std::shared_ptr<Block> m_asmBlock;
ErrorList m_errors;
};
}
}
}

17
libsolidity/parsing/Parser.cpp
View File

@ -735,16 +735,17 @@ ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> con
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Assembly);
if (m_scanner->currentToken() != Token::StringLiteral)
fatalParserError("Expected assembly name.");
if (m_scanner->currentLiteral() != "evmasm")
fatalParserError("Only \"evmasm\" supported.");
m_scanner->next();
if (m_scanner->currentToken() == Token::StringLiteral)
{
if (m_scanner->currentLiteral() != "evmasm")
fatalParserError("Only \"evmasm\" supported.");
m_scanner->next();
}
InlineAssemblyParser parser(m_errors);
shared_ptr<InlineAssemblyBlock> operations = parser.parse(m_scanner);
assembly::Parser asmParser(m_errors);
shared_ptr<assembly::Block> block = asmParser.parse(m_scanner);
nodeFactory.markEndPosition();
return nodeFactory.createNode<InlineAssembly>(_docString, operations);
return nodeFactory.createNode<InlineAssembly>(_docString, block);
}
ASTPointer<IfStatement> Parser::parseIfStatement(ASTPointer<ASTString> const& _docString)

35
solc/CommandLineInterface.cpp
View File

@ -773,7 +773,7 @@ void CommandLineInterface::handleAst(string const& _argStr)
void CommandLineInterface::actOnInput()
{
if (m_onlyAssemble)
return; //@TODO
outputAssembly();
else if (m_onlyLink)
writeLinkedFiles();
else
@ -831,27 +831,40 @@ bool CommandLineInterface::assemble()
{
//@TODO later, we will use the convenience interface and should also remove the include above
bool successful = true;
ErrorList errors;
map<string, shared_ptr<Scanner>> scanners;
for (auto const& src: m_sourceCodes)
{
auto scanner = make_shared<Scanner>(CharStream(src.second), src.first);
scanners[src.first] = scanner;
InlineAssemblyParser parser(errors);
if (!parser.parse(scanner))
if (!m_assemblyStacks[src.first].parse(scanner))
successful = false;
else
//@TODO we should not just throw away the result here
m_assemblyStacks[src.first].assemble();
}
for (auto const& error: errors)
SourceReferenceFormatter::printExceptionInformation(
cerr,
*error,
(error->type() == Error::Type::Warning) ? "Warning" : "Error",
[&](string const& _source) -> Scanner const& { return *scanners.at(_source); }
);
for (auto const& stack: m_assemblyStacks)
for (auto const& error: stack.second.errors())
SourceReferenceFormatter::printExceptionInformation(
cerr,
*error,
(error->type() == Error::Type::Warning) ? "Warning" : "Error",
[&](string const& _source) -> Scanner const& { return *scanners.at(_source); }
);
return successful;
}
void CommandLineInterface::outputAssembly()
{
for (auto const& src: m_sourceCodes)
{
cout << endl << "======= " << src.first << " =======" << endl;
eth::Assembly assembly = m_assemblyStacks[src.first].assemble();
cout << assembly.assemble().toHex() << endl;
cout << assembly.out();
}
}
void CommandLineInterface::outputCompilationResults()
{
handleCombinedJSON();

6
solc/CommandLineInterface.h
View File

@ -21,10 +21,11 @@
*/
#pragma once
#include <libsolidity/interface/CompilerStack.h>
#include <memory>
#include <boost/program_options.hpp>
#include <boost/filesystem/path.hpp>
#include <libsolidity/interface/CompilerStack.h>
#include <libsolidity/inlineasm/AsmStack.h>
namespace dev
{
@ -52,6 +53,7 @@ private:
/// Parse assembly input.
bool assemble();
void outputAssembly();
void outputCompilationResults();
@ -91,6 +93,8 @@ private:
std::map<std::string, h160> m_libraries;
/// Solidity compiler stack
std::unique_ptr<dev::solidity::CompilerStack> m_compiler;
/// Assembly stacks for assembly-only mode
std::map<std::string, assembly::InlineAssemblyStack> m_assemblyStacks;
};
}

41
test/libsolidity/InlineAssembly.cpp
View File

@ -23,8 +23,9 @@
#include <string>
#include <memory>
#include <libdevcore/Log.h>
#include <libevmasm/Assembly.h>
#include <libsolidity/parsing/Scanner.h>
#include <libsolidity/inlineasm/AsmParser.h>
#include <libsolidity/inlineasm/AsmStack.h>
#include <libsolidity/interface/Exceptions.h>
#include <libsolidity/ast/AST.h>
#include "../TestHelper.h"
@ -40,32 +41,38 @@ namespace test
namespace
{
shared_ptr<InlineAssemblyBlock> parse(std::string const& _source, ErrorList& _errors)
{
return InlineAssemblyParser(_errors).parse(std::make_shared<Scanner>(CharStream(_source)));
}
bool successParse(std::string const& _source)
bool successParse(std::string const& _source, bool _assemble = false)
{
ErrorList errors;
assembly::InlineAssemblyStack stack;
try
{
auto assembly = parse(_source, errors);
if (!assembly)
if (!stack.parse(std::make_shared<Scanner>(CharStream(_source))))
return false;
if (_assemble)
{
stack.assemble();
if (!stack.errors().empty())
return false;
}
}
catch (FatalError const&)
{
if (Error::containsErrorOfType(errors, Error::Type::ParserError))
if (Error::containsErrorOfType(stack.errors(), Error::Type::ParserError))
return false;
}
if (Error::containsErrorOfType(errors, Error::Type::ParserError))
if (Error::containsErrorOfType(stack.errors(), Error::Type::ParserError))
return false;
BOOST_CHECK(Error::containsOnlyWarnings(errors));
BOOST_CHECK(Error::containsOnlyWarnings(stack.errors()));
return true;
}
bool successAssemble(string const& _source)
{
return successParse(_source, true);
}
}
@ -131,6 +138,16 @@ BOOST_AUTO_TEST_CASE(blocks)
BOOST_CHECK(successParse("{ let x := 7 { let y := 3 } { let z := 2 } }"));
}
BOOST_AUTO_TEST_CASE(string_literals)
{
BOOST_CHECK(successAssemble("{ let x := \"12345678901234567890123456789012\" }"));
}
BOOST_AUTO_TEST_CASE(oversize_string_literals)
{
BOOST_CHECK(!successAssemble("{ let x := \"123456789012345678901234567890123\" }"));
}
BOOST_AUTO_TEST_SUITE_END()
}

89
test/libsolidity/SolidityEndToEndTest.cpp
View File

@ -6486,6 +6486,95 @@ BOOST_AUTO_TEST_CASE(fixed_bytes_length_access)
BOOST_CHECK(callContractFunction("f(bytes32)", "789") == encodeArgs(u256(32), u256(16), u256(8)));
}
BOOST_AUTO_TEST_CASE(inline_assembly_write_to_stack)
{
char const* sourceCode = R"(
contract C {
function f() returns (uint r, bytes32 r2) {
assembly { r := 7 r2 := "abcdef" }
}
}
)";
compileAndRun(sourceCode, 0, "C");
BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(7), string("abcdef")));
}
BOOST_AUTO_TEST_CASE(inline_assembly_read_and_write_stack)
{
char const* sourceCode = R"(
contract C {
function f() returns (uint r) {
for (uint x = 0; x < 10; ++x)
assembly { r := add(r, x) }
}
}
)";
compileAndRun(sourceCode, 0, "C");
BOOST_CHECK(callContractFunction("f()") == encodeArgs(u256(45)));
}
BOOST_AUTO_TEST_CASE(inline_assembly_memory_access)
{
char const* sourceCode = R"(
contract C {
function test() returns (bytes) {
bytes memory x = new bytes(5);
for (uint i = 0; i < x.length; ++i)
x[i] = byte(i + 1);
assembly { mstore(add(x, 32), "12345678901234567890123456789012") }
return x;
}
}
)";
compileAndRun(sourceCode, 0, "C");
BOOST_CHECK(callContractFunction("test()") == encodeArgs(u256(0x20), u256(5), string("12345")));
}
BOOST_AUTO_TEST_CASE(inline_assembly_storage_access)
{
char const* sourceCode = R"(
contract C {
uint16 x;
uint16 public y;
uint public z;
function f() {
// we know that z is aligned because it is too large, so we just discard its
// intra-slot offset value
assembly { 7 z pop sstore }
}
}
)";
compileAndRun(sourceCode, 0, "C");
BOOST_CHECK(callContractFunction("f()") == encodeArgs());
BOOST_CHECK(callContractFunction("z()") == encodeArgs(u256(7)));
}
BOOST_AUTO_TEST_CASE(inline_assembly_jumps)
{
char const* sourceCode = R"(
contract C {
function f() {
assembly {
let n := calldataload(4)
let a := 1
let b := a
loop:
jumpi(loopend, eq(n, 0))
a add swap1
n := sub(n, 1)
jump(loop)
loopend:
mstore(0, a)
return(0, 0x20)
}
}
}
)";
compileAndRun(sourceCode, 0, "C");
BOOST_CHECK(callContractFunction("f()", u256(5)) == encodeArgs(u256(13)));
BOOST_CHECK(callContractFunction("f()", u256(7)) == encodeArgs(u256(34)));
}
BOOST_AUTO_TEST_SUITE_END()
}