aboutsummaryrefslogtreecommitdiffstats
path: root/libyul/optimiser/SimplificationRules.h
blob: b608ca91dec6bd6a8b5ca28ae0b59070d4d2bf86 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
    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/>.
*/
/**
 * Module for applying replacement rules against Expressions.
 */

#pragma once

#include <libevmasm/ExpressionClasses.h>
#include <libevmasm/SimplificationRule.h>

#include <libyul/ASTDataForward.h>

#include <libsolidity/inlineasm/AsmData.h>

#include <boost/noncopyable.hpp>

#include <functional>
#include <vector>

namespace dev
{
namespace yul
{

class Pattern;

/**
 * Container for all simplification rules.
 */
class SimplificationRules: public boost::noncopyable
{
public:
    SimplificationRules();

    /// @returns a pointer to the first matching pattern and sets the match
    /// groups accordingly.
    /// @param _ssaValues values of variables that are assigned exactly once.
    static SimplificationRule<Pattern> const* findFirstMatch(
        Expression const& _expr,
        std::map<YulString, Expression const*> const& _ssaValues
    );

    /// Checks whether the rulelist is non-empty. This is usually enforced
    /// by the constructor, but we had some issues with static initialization.
    bool isInitialized() const;
private:
    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<SimplificationRule<Pattern>> m_rules[256];
};

enum class PatternKind
{
    Operation,
    Constant,
    Any
};

/**
 * Pattern to match against an expression.
 * Also stores matched expressions to retrieve them later, for constructing new expressions using
 * ExpressionTemplate.
 */
class Pattern
{
public:
    /// Matches any expression.
    Pattern(PatternKind _kind = PatternKind::Any): m_kind(_kind) {}
    // Matches a specific constant value.
    Pattern(unsigned _value): Pattern(u256(_value)) {}
    // Matches a specific constant value.
    Pattern(u256 const& _value): m_kind(PatternKind::Constant), m_data(std::make_shared<u256>(_value)) {}
    // Matches a given instruction with given arguments
    Pattern(solidity::Instruction _instruction, std::vector<Pattern> const& _arguments = {});
    /// Sets this pattern to be part of the match group with the identifier @a _group.
    /// Inside one rule, all patterns in the same match group have to match expressions from the
    /// same expression equivalence class.
    void setMatchGroup(unsigned _group, std::map<unsigned, Expression const*>& _matchGroups);
    unsigned matchGroup() const { return m_matchGroup; }
    bool matches(Expression const& _expr, std::map<YulString, Expression const*> const& _ssaValues) const;

    std::vector<Pattern> arguments() const { return m_arguments; }

    /// @returns the data of the matched expression if this pattern is part of a match group.
    u256 d() const;

    solidity::Instruction instruction() const;

    /// Turns this pattern into an actual expression. Should only be called
    /// for patterns resulting from an action, i.e. with match groups assigned.
    Expression toExpression(SourceLocation const& _location) const;

private:
    Expression const& matchGroupValue() const;

    PatternKind m_kind = PatternKind::Any;
    solidity::Instruction m_instruction; ///< Only valid if m_kind is Operation
    std::shared_ptr<u256> m_data; ///< Only valid if m_kind is Constant
    std::vector<Pattern> m_arguments;
    unsigned m_matchGroup = 0;
    std::map<unsigned, Expression const*>* m_matchGroups = nullptr;
};

}
}