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
/*
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/>.
*/
// SPDX-License-Identifier: GPL-3.0
#pragma once
#include <libyul/optimiser/ASTWalker.h>
#include <libyul/optimiser/NameDispenser.h>
#include <libyul/optimiser/OptimiserStep.h>
#include <libyul/ASTForward.h>
#include <libyul/Dialect.h>
#include <map>
#include <optional>
#include <vector>
namespace solidity::yul
{
/**
* FunctionSpecializer: Optimiser step that specializes the function with its literal arguments.
*
* If a function, say, `function f(a, b) { sstore (a, b)}`, is called with literal arguments, for
* example, `f(x, 5)`, where `x` is an identifier, it could be specialized by creating a new
* function `f_1` that takes only one argument, i.e.,
*
* function f_1(a_1) {
* let b_1 := 5
* sstore(a_1, b_1)
* }
*
* Other optimization steps will be able to make more simplifications to the function. The
* optimization step is mainly useful for functions that would not be inlined.
*
* Prerequisites: Disambiguator, FunctionHoister
*
* LiteralRematerialiser is recommended as a prerequisite, even though it's not required for
* correctness.
*/
class FunctionSpecializer: public ASTModifier
{
public:
/// A vector of function-call arguments. An element 'has value' if it's a literal, and the
/// corresponding Expression would be the literal.
using LiteralArguments = std::vector<std::optional<Expression>>;
static constexpr char const* name{"FunctionSpecializer"};
static void run(OptimiserStepContext& _context, Block& _ast);
using ASTModifier::operator();
void operator()(FunctionCall& _f) override;
private:
explicit FunctionSpecializer(
std::set<YulString> _recursiveFunctions,
NameDispenser& _nameDispenser,
Dialect const& _dialect
):
m_recursiveFunctions(std::move(_recursiveFunctions)),
m_nameDispenser(_nameDispenser),
m_dialect(_dialect)
{}
/// Returns a vector of Expressions, where the index `i` is an expression if the function's
/// `i`-th argument can be specialized, nullopt otherwise.
LiteralArguments specializableArguments(FunctionCall const& _f);
/// Given a function definition `_f` and its arguments `_arguments`, of which, at least one is a
/// literal, this function returns a new function with the literal arguments specialized.
///
/// Note that the returned function definition will have new (and unique) names, for both the
/// function and variable declarations to retain the properties enforced by the Disambiguator.
///
/// For example, if `_f` is the function `function f(a, b, c) -> d { sstore(a, b) }`,
/// `_arguments` is the vector of literals `{1, 2, nullopt}` and the @param, `_newName` has
/// value `f_1`, the returned function could be:
///
/// function f_1(c_2) -> d_3 {
/// let a_4 := 1
/// let b_5 := 2
/// sstore(a_4, b_5)
/// }
///
FunctionDefinition specialize(
FunctionDefinition const& _f,
YulString _newName,
FunctionSpecializer::LiteralArguments _arguments
);
/// A mapping between the old function name and a pair of new function name and its arguments.
/// Note that at least one of the argument will have a literal value.
std::map<YulString, std::vector<std::pair<YulString, LiteralArguments>>> m_oldToNewMap;
/// We skip specializing recursive functions. Need backtracking to properly deal with them.
std::set<YulString> const m_recursiveFunctions;
NameDispenser& m_nameDispenser;
Dialect const& m_dialect;
};
}