mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
Turn simplification rule tuple into struct.
This commit is contained in:
parent
5523296eaa
commit
c961a3079d
@ -202,7 +202,7 @@ ExpressionClasses::Id ExpressionClasses::tryToSimplify(Expression const& _expr)
|
||||
//cout << "with rule " << match->first.toString() << endl;
|
||||
//ExpressionTemplate t(match->second());
|
||||
//cout << "to " << match->second().toString() << endl;
|
||||
return rebuildExpression(ExpressionTemplate(std::get<1>(*match)(), _expr.item->location()));
|
||||
return rebuildExpression(ExpressionTemplate(match->action(), _expr.item->location()));
|
||||
}
|
||||
|
||||
return -1;
|
||||
|
@ -25,6 +25,7 @@
|
||||
#include <functional>
|
||||
|
||||
#include <libevmasm/Instruction.h>
|
||||
#include <libevmasm/SimplificationRule.h>
|
||||
|
||||
#include <libdevcore/CommonData.h>
|
||||
|
||||
@ -45,12 +46,10 @@ template <class S> S modWorkaround(S const& _a, S const& _b)
|
||||
|
||||
/// @returns a list of simplification rules given certain match placeholders.
|
||||
/// A, B and C should represent constants, X and Y arbitrary expressions.
|
||||
/// The third element in the tuple is a boolean flag that indicates whether
|
||||
/// any non-constant elements in the pattern are removed by applying it.
|
||||
/// The simplifications should neven change the order of evaluation of
|
||||
/// arbitrary operations, though.
|
||||
/// arbitrary operations.
|
||||
template <class Pattern>
|
||||
std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> simplificationRuleList(
|
||||
std::vector<SimplificationRule<Pattern>> simplificationRuleList(
|
||||
Pattern A,
|
||||
Pattern B,
|
||||
Pattern C,
|
||||
@ -58,8 +57,8 @@ std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> simplificationR
|
||||
Pattern Y
|
||||
)
|
||||
{
|
||||
std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> rules;
|
||||
rules += std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>>{
|
||||
std::vector<SimplificationRule<Pattern>> rules;
|
||||
rules += std::vector<SimplificationRule<Pattern>>{
|
||||
// arithmetics on constants
|
||||
{{Instruction::ADD, {A, B}}, [=]{ return A.d() + B.d(); }, false},
|
||||
{{Instruction::MUL, {A, B}}, [=]{ return A.d() * B.d(); }, false},
|
||||
@ -196,7 +195,7 @@ std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> simplificationR
|
||||
// xa can be (X, A) or (A, X)
|
||||
for (auto xa: {std::vector<Pattern>{X, A}, std::vector<Pattern>{A, X}})
|
||||
{
|
||||
rules += std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>>{{
|
||||
rules += std::vector<SimplificationRule<Pattern>>{{
|
||||
// (X+A)+B -> X+(A+B)
|
||||
{op, {{op, xa}, B}},
|
||||
[=]() -> Pattern { return {op, {X, fun(A.d(), B.d())}}; },
|
||||
@ -221,7 +220,7 @@ std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> simplificationR
|
||||
}
|
||||
|
||||
// move constants across subtractions
|
||||
rules += std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>>{
|
||||
rules += std::vector<SimplificationRule<Pattern>>{
|
||||
{
|
||||
// X - A -> X + (-A)
|
||||
{Instruction::SUB, {X, A}},
|
||||
|
45
libevmasm/SimplificationRule.h
Normal file
45
libevmasm/SimplificationRule.h
Normal file
@ -0,0 +1,45 @@
|
||||
/*
|
||||
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/>.
|
||||
*/
|
||||
/**
|
||||
* Expression simplification pattern.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <functional>
|
||||
|
||||
namespace dev
|
||||
{
|
||||
namespace solidity
|
||||
{
|
||||
|
||||
/**
|
||||
* Rule that contains a pattern, an action that can be applied
|
||||
* after the pattern has matched and a bool that indicates
|
||||
* whether the action would remove something from the expression
|
||||
* than is not a constant literal.
|
||||
*/
|
||||
template <class Pattern>
|
||||
struct SimplificationRule
|
||||
{
|
||||
Pattern pattern;
|
||||
std::function<Pattern()> action;
|
||||
bool removesNonConstants;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
@ -23,7 +23,6 @@
|
||||
|
||||
#include <libevmasm/ExpressionClasses.h>
|
||||
#include <utility>
|
||||
#include <tuple>
|
||||
#include <functional>
|
||||
#include <boost/range/adaptor/reversed.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
@ -38,7 +37,7 @@ using namespace dev;
|
||||
using namespace dev::eth;
|
||||
|
||||
|
||||
tuple<Pattern, function<Pattern()>, bool> const* Rules::findFirstMatch(
|
||||
SimplificationRule<Pattern> const* Rules::findFirstMatch(
|
||||
Expression const& _expr,
|
||||
ExpressionClasses const& _classes
|
||||
)
|
||||
@ -48,22 +47,22 @@ tuple<Pattern, function<Pattern()>, bool> const* Rules::findFirstMatch(
|
||||
assertThrow(_expr.item, OptimizerException, "");
|
||||
for (auto const& rule: m_rules[byte(_expr.item->instruction())])
|
||||
{
|
||||
if (std::get<0>(rule).matches(_expr, _classes))
|
||||
if (rule.pattern.matches(_expr, _classes))
|
||||
return &rule;
|
||||
resetMatchGroups();
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void Rules::addRules(std::vector<std::tuple<Pattern, std::function<Pattern ()>, bool>> const& _rules)
|
||||
void Rules::addRules(std::vector<SimplificationRule<Pattern>> const& _rules)
|
||||
{
|
||||
for (auto const& r: _rules)
|
||||
addRule(r);
|
||||
}
|
||||
|
||||
void Rules::addRule(std::tuple<Pattern, std::function<Pattern()>, bool> const& _rule)
|
||||
void Rules::addRule(SimplificationRule<Pattern> const& _rule)
|
||||
{
|
||||
m_rules[byte(std::get<0>(_rule).instruction())].push_back(_rule);
|
||||
m_rules[byte(_rule.pattern.instruction())].push_back(_rule);
|
||||
}
|
||||
|
||||
Rules::Rules()
|
||||
|
@ -24,6 +24,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <libevmasm/ExpressionClasses.h>
|
||||
#include <libevmasm/SimplificationRule.h>
|
||||
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
@ -47,21 +48,21 @@ public:
|
||||
|
||||
/// @returns a pointer to the first matching pattern and sets the match
|
||||
/// groups accordingly.
|
||||
std::tuple<Pattern, std::function<Pattern()>, bool> const* findFirstMatch(
|
||||
SimplificationRule<Pattern> const* findFirstMatch(
|
||||
Expression const& _expr,
|
||||
ExpressionClasses const& _classes
|
||||
);
|
||||
|
||||
private:
|
||||
void addRules(std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> const& _rules);
|
||||
void addRule(std::tuple<Pattern, std::function<Pattern()>, bool> const& _rule);
|
||||
void addRules(std::vector<SimplificationRule<Pattern>> const& _rules);
|
||||
void addRule(SimplificationRule<Pattern> const& _rule);
|
||||
|
||||
void resetMatchGroups() { m_matchGroups.clear(); }
|
||||
|
||||
std::map<unsigned, Expression const*> m_matchGroups;
|
||||
/// Pattern to match, replacement to be applied and flag indicating whether
|
||||
/// the replacement might remove some elements (except constants).
|
||||
std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> m_rules[256];
|
||||
std::vector<SimplificationRule<Pattern>> m_rules[256];
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -43,8 +43,8 @@ void ExpressionSimplifier::visit(Expression& _expression)
|
||||
// Do not apply the rule if it removes non-constant parts of the expression.
|
||||
// TODO: The check could actually be less strict than "movable".
|
||||
// We only require "Does not cause side-effects".
|
||||
if (std::get<2>(*match) && !MovableChecker(_expression).movable())
|
||||
if (match->removesNonConstants && !MovableChecker(_expression).movable())
|
||||
return;
|
||||
_expression = std::get<1>(*match)().toExpression(locationOf(_expression));
|
||||
_expression = match->action().toExpression(locationOf(_expression));
|
||||
}
|
||||
}
|
||||
|
@ -34,7 +34,7 @@ using namespace dev;
|
||||
using namespace dev::julia;
|
||||
|
||||
|
||||
tuple<Pattern, function<Pattern()>, bool> const* SimplificationRules::findFirstMatch(Expression const& _expr)
|
||||
SimplificationRule<Pattern> const* SimplificationRules::findFirstMatch(Expression const& _expr)
|
||||
{
|
||||
if (_expr.type() != typeid(FunctionalInstruction))
|
||||
return nullptr;
|
||||
@ -45,21 +45,21 @@ tuple<Pattern, function<Pattern()>, bool> const* SimplificationRules::findFirstM
|
||||
for (auto const& rule: rules.m_rules[byte(instruction.instruction)])
|
||||
{
|
||||
rules.resetMatchGroups();
|
||||
if (std::get<0>(rule).matches(_expr))
|
||||
if (rule.pattern.matches(_expr))
|
||||
return &rule;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void SimplificationRules::addRules(vector<tuple<Pattern, function<Pattern()>, bool>> const& _rules)
|
||||
void SimplificationRules::addRules(vector<SimplificationRule<Pattern>> const& _rules)
|
||||
{
|
||||
for (auto const& r: _rules)
|
||||
addRule(r);
|
||||
}
|
||||
|
||||
void SimplificationRules::addRule(tuple<Pattern, function<Pattern()>, bool> const& _rule)
|
||||
void SimplificationRules::addRule(SimplificationRule<Pattern> const& _rule)
|
||||
{
|
||||
m_rules[byte(std::get<0>(_rule).instruction())].push_back(_rule);
|
||||
m_rules[byte(_rule.pattern.instruction())].push_back(_rule);
|
||||
}
|
||||
|
||||
SimplificationRules::SimplificationRules()
|
||||
|
@ -21,6 +21,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <libevmasm/ExpressionClasses.h>
|
||||
#include <libevmasm/SimplificationRule.h>
|
||||
|
||||
#include <libjulia/ASTDataForward.h>
|
||||
|
||||
@ -48,16 +49,16 @@ public:
|
||||
|
||||
/// @returns a pointer to the first matching pattern and sets the match
|
||||
/// groups accordingly.
|
||||
static std::tuple<Pattern, std::function<Pattern()>, bool> const* findFirstMatch(Expression const& _expr);
|
||||
static SimplificationRule<Pattern> const* findFirstMatch(Expression const& _expr);
|
||||
|
||||
private:
|
||||
void addRules(std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> const& _rules);
|
||||
void addRule(std::tuple<Pattern, std::function<Pattern()>, bool> const& _rule);
|
||||
void addRules(std::vector<SimplificationRule<Pattern>> const& _rules);
|
||||
void addRule(SimplificationRule<Pattern> const& _rule);
|
||||
|
||||
void resetMatchGroups() { m_matchGroups.clear(); }
|
||||
|
||||
std::map<unsigned, Expression const*> m_matchGroups;
|
||||
std::vector<std::tuple<Pattern, std::function<Pattern()>, bool>> m_rules[256];
|
||||
std::vector<SimplificationRule<Pattern>> m_rules[256];
|
||||
};
|
||||
|
||||
enum class PatternKind
|
||||
|
Loading…
Reference in New Issue
Block a user