Skip to content

Commit

Permalink
Merge pull request ethereum#3352 from ethereum/movability
Browse files Browse the repository at this point in the history
Movability check
  • Loading branch information
axic authored Jan 16, 2018
2 parents 14fcbd6 + 95cf926 commit fc7733c
Show file tree
Hide file tree
Showing 7 changed files with 176 additions and 16 deletions.
25 changes: 25 additions & 0 deletions libevmasm/SemanticInformation.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -153,6 +153,31 @@ bool SemanticInformation::isDeterministic(AssemblyItem const& _item)
}
}

bool SemanticInformation::movable(Instruction _instruction)
{
// These are not really functional.
if (isDupInstruction(_instruction) || isSwapInstruction(_instruction))
return false;
InstructionInfo info = instructionInfo(_instruction);
if (info.sideEffects)
return false;
switch (_instruction)
{
case Instruction::KECCAK256:
case Instruction::BALANCE:
case Instruction::EXTCODESIZE:
case Instruction::RETURNDATASIZE:
case Instruction::SLOAD:
case Instruction::PC:
case Instruction::MSIZE:
case Instruction::GAS:
return false;
default:
return true;
}
return true;
}

bool SemanticInformation::invalidatesMemory(Instruction _instruction)
{
switch (_instruction)
Expand Down
4 changes: 4 additions & 0 deletions libevmasm/SemanticInformation.h
Original file line number Diff line number Diff line change
Expand Up @@ -49,6 +49,10 @@ struct SemanticInformation
/// @returns false if the value put on the stack by _item depends on anything else than
/// the information in the current block header, memory, storage or stack.
static bool isDeterministic(AssemblyItem const& _item);
/// @returns true if the instruction can be moved or copied (together with its arguments)
/// without altering the semantics. This means it cannot depend on storage or memory,
/// cannot have any side-effects, but it can depend on a call-constant state of the blockchain.
static bool movable(solidity::Instruction _instruction);
/// @returns true if the given instruction modifies memory.
static bool invalidatesMemory(solidity::Instruction _instruction);
/// @returns true if the given instruction modifies storage (even indirectly).
Expand Down
14 changes: 7 additions & 7 deletions libjulia/optimiser/ASTWalker.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -44,31 +44,31 @@ void ASTWalker::operator()(FunctionCall const& _funCall)

void ASTWalker::operator()(ExpressionStatement const& _statement)
{
boost::apply_visitor(*this, _statement.expression);
visit(_statement.expression);
}

void ASTWalker::operator()(Assignment const& _assignment)
{
for (auto const& name: _assignment.variableNames)
(*this)(name);
boost::apply_visitor(*this, *_assignment.value);
visit(*_assignment.value);
}

void ASTWalker::operator()(VariableDeclaration const& _varDecl)
{
if (_varDecl.value)
boost::apply_visitor(*this, *_varDecl.value);
visit(*_varDecl.value);
}

void ASTWalker::operator()(If const& _if)
{
boost::apply_visitor(*this, *_if.condition);
visit(*_if.condition);
(*this)(_if.body);
}

void ASTWalker::operator()(Switch const& _switch)
{
boost::apply_visitor(*this, *_switch.expression);
visit(*_switch.expression);
for (auto const& _case: _switch.cases)
{
if (_case.value)
Expand All @@ -85,7 +85,7 @@ void ASTWalker::operator()(FunctionDefinition const& _fun)
void ASTWalker::operator()(ForLoop const& _for)
{
(*this)(_for.pre);
boost::apply_visitor(*this, *_for.condition);
visit(*_for.condition);
(*this)(_for.post);
(*this)(_for.body);
}
Expand All @@ -107,7 +107,7 @@ void ASTModifier::operator()(FunctionCall& _funCall)

void ASTModifier::operator()(ExpressionStatement& _statement)
{
boost::apply_visitor(*this, _statement.expression);
visit(_statement.expression);
}

void ASTModifier::operator()(Assignment& _assignment)
Expand Down
26 changes: 18 additions & 8 deletions libjulia/optimiser/ASTWalker.h
Original file line number Diff line number Diff line change
Expand Up @@ -58,12 +58,21 @@ class ASTWalker: public boost::static_visitor<>
virtual void operator()(ForLoop const&);
virtual void operator()(Block const& _block);

virtual void visit(Statement const& _st)
{
boost::apply_visitor(*this, _st);
}
virtual void visit(Expression const& _e)
{
boost::apply_visitor(*this, _e);
}

protected:
template <class T>
void walkVector(T const& _statements)
{
for (auto const& st: _statements)
boost::apply_visitor(*this, st);
visit(st);
}
};

Expand All @@ -89,13 +98,6 @@ class ASTModifier: public boost::static_visitor<>
virtual void operator()(ForLoop&);
virtual void operator()(Block& _block);

protected:
template <class T>
void walkVector(T&& _statements)
{
for (auto& st: _statements)
visit(st);
}
virtual void visit(Statement& _st)
{
boost::apply_visitor(*this, _st);
Expand All @@ -104,6 +106,14 @@ class ASTModifier: public boost::static_visitor<>
{
boost::apply_visitor(*this, _e);
}

protected:
template <class T>
void walkVector(T&& _statements)
{
for (auto& st: _statements)
visit(st);
}
};

}
Expand Down
1 change: 0 additions & 1 deletion libjulia/optimiser/Disambiguator.h
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,6 @@ namespace dev
{
namespace julia
{
class EVMAssembly;

/**
* Creates a copy of a iulia AST replacing all identifiers by unique names.
Expand Down
60 changes: 60 additions & 0 deletions libjulia/optimiser/Semantics.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,60 @@
/*(
This file is part of solidity.
solidity 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.
solidity 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 solidity. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* Specific AST walkers that collect semantical facts.
*/

#include <libjulia/optimiser/Semantics.h>

#include <libsolidity/inlineasm/AsmData.h>

#include <libevmasm/SemanticInformation.h>

#include <libdevcore/CommonData.h>

using namespace std;
using namespace dev;
using namespace dev::julia;

MovableChecker::MovableChecker(Expression const& _expression)
{
visit(_expression);
}

void MovableChecker::operator()(Identifier const& _identifier)
{
ASTWalker::operator()(_identifier);
m_variableReferences.insert(_identifier.name);
}

void MovableChecker::operator()(FunctionalInstruction const& _instr)
{
if (!eth::SemanticInformation::movable(_instr.instruction))
m_movable = false;
else
ASTWalker::operator()(_instr);
}

void MovableChecker::operator()(FunctionCall const&)
{
m_movable = false;
}

void MovableChecker::visit(Statement const&)
{
solAssert(false, "Movability for statement requested.");
}
62 changes: 62 additions & 0 deletions libjulia/optimiser/Semantics.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,62 @@
/*
This file is part of solidity.
solidity 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.
solidity 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 solidity. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* Specific AST walkers that collect semantical facts.
*/

#pragma once

#include <libjulia/optimiser/ASTWalker.h>

#include <string>
#include <map>
#include <set>

namespace dev
{
namespace julia
{

/**
* Specific AST walker that determines whether an expression is movable.
*/
class MovableChecker: public ASTWalker
{
public:
MovableChecker() = default;
explicit MovableChecker(Expression const& _expression);

virtual void operator()(Identifier const& _identifier) override;
virtual void operator()(FunctionalInstruction const& _functionalInstruction) override;
virtual void operator()(FunctionCall const& _functionCall) override;

/// Disallow visiting anything apart from Expressions (this throws).
virtual void visit(Statement const&) override;
using ASTWalker::visit;

bool movable() const { return m_movable; }
std::set<std::string> const& referencedVariables() const { return m_variableReferences; }

private:
/// Which variables the current expression references.
std::set<std::string> m_variableReferences;
/// Is the current expression movable or not.
bool m_movable = true;
};

}
}

0 comments on commit fc7733c

Please sign in to comment.