solidity/libyul/optimiser/StackCompressor.cpp

284 lines
8.9 KiB
C++
Raw Normal View History

2019-02-04 16:30:29 +00:00
/*(
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/>.
*/
/**
* Optimisation stage that aggressively rematerializes certain variables ina a function to free
* space on the stack until it is compilable.
*/
#include <libyul/optimiser/StackCompressor.h>
#include <libyul/optimiser/NameCollector.h>
#include <libyul/optimiser/Rematerialiser.h>
#include <libyul/optimiser/UnusedPruner.h>
#include <libyul/optimiser/Metrics.h>
#include <libyul/optimiser/Semantics.h>
#include <libyul/backends/evm/ControlFlowGraphBuilder.h>
#include <libyul/backends/evm/StackHelpers.h>
#include <libyul/backends/evm/StackLayoutGenerator.h>
#include <libyul/AsmAnalysis.h>
#include <libyul/AsmAnalysisInfo.h>
2019-02-04 16:30:29 +00:00
#include <libyul/CompilabilityChecker.h>
#include <libyul/AST.h>
2019-02-04 16:30:29 +00:00
#include <libsolutil/CommonData.h>
2019-12-11 16:31:36 +00:00
using namespace solidity;
using namespace solidity::yul;
2019-02-04 16:30:29 +00:00
namespace
{
/**
* Class that discovers all variables that can be fully eliminated by rematerialization,
* and the corresponding approximate costs.
2022-03-15 17:10:52 +00:00
*
* Prerequisite: Disambiguator, Function Grouper
*/
class RematCandidateSelector: public DataFlowAnalyzer
2019-02-04 16:30:29 +00:00
{
public:
explicit RematCandidateSelector(Dialect const& _dialect): DataFlowAnalyzer(_dialect, MemoryAndStorage::Ignore) {}
2022-03-15 17:10:52 +00:00
/// @returns a map from function name to rematerialisation costs to a vector of variables to rematerialise
/// and variables that occur in their expression.
/// While the map is sorted by cost, the contained vectors are sorted by the order of occurrence.
std::map<YulString, std::map<size_t, std::vector<YulString>>> candidates()
{
std::map<YulString, std::map<size_t, std::vector<YulString>>> cand;
2022-03-15 17:10:52 +00:00
for (auto const& [functionName, candidate]: m_candidates)
{
if (size_t const* cost = util::valueOrNullptr(m_expressionCodeCost, candidate))
{
size_t numRef = m_numReferences[candidate];
2022-03-16 15:43:21 +00:00
cand[functionName][*cost * numRef].emplace_back(candidate);
}
}
return cand;
}
using DataFlowAnalyzer::operator();
2022-03-15 17:10:52 +00:00
void operator()(FunctionDefinition& _function) override
{
yulAssert(m_currentFunctionName.empty());
m_currentFunctionName = _function.name;
DataFlowAnalyzer::operator()(_function);
m_currentFunctionName = {};
}
void operator()(VariableDeclaration& _varDecl) override
{
DataFlowAnalyzer::operator()(_varDecl);
if (_varDecl.variables.size() == 1)
{
YulString varName = _varDecl.variables.front().name;
if (AssignedValue const* value = variableValue(varName))
{
yulAssert(!m_expressionCodeCost.count(varName), "");
2022-03-15 17:10:52 +00:00
m_candidates.emplace_back(m_currentFunctionName, varName);
m_expressionCodeCost[varName] = CodeCost::codeCost(m_dialect, *value->value);
}
}
}
2019-02-04 16:30:29 +00:00
void operator()(Assignment& _assignment) override
{
for (auto const& var: _assignment.variableNames)
rematImpossible(var.name);
DataFlowAnalyzer::operator()(_assignment);
}
// We use visit(Expression) because operator()(Identifier) would also
// get called on left-hand-sides of assignments.
void visit(Expression& _e) override
{
if (std::holds_alternative<Identifier>(_e))
{
YulString name = std::get<Identifier>(_e).name;
if (m_expressionCodeCost.count(name))
{
if (!variableValue(name))
rematImpossible(name);
else
++m_numReferences[name];
}
}
DataFlowAnalyzer::visit(_e);
}
2019-02-04 16:30:29 +00:00
/// Remove the variable from the candidate set.
void rematImpossible(YulString _variable)
2019-02-04 16:30:29 +00:00
{
m_numReferences.erase(_variable);
m_expressionCodeCost.erase(_variable);
2019-02-04 16:30:29 +00:00
}
2022-03-15 17:10:52 +00:00
YulString m_currentFunctionName = {};
/// All candidate variables by function name, in order of occurrence.
std::vector<std::pair<YulString, YulString>> m_candidates;
/// Candidate variables and the code cost of their value.
std::map<YulString, size_t> m_expressionCodeCost;
/// Number of references to each candidate variable.
std::map<YulString, size_t> m_numReferences;
};
/// Selects at most @a _numVariables among @a _candidates.
std::set<YulString> chooseVarsToEliminate(
std::map<size_t, std::vector<YulString>> const& _candidates,
size_t _numVariables
)
{
std::set<YulString> varsToEliminate;
for (auto&& [cost, candidates]: _candidates)
2022-03-16 15:43:21 +00:00
for (auto&& candidate: candidates)
{
if (varsToEliminate.size() >= _numVariables)
return varsToEliminate;
varsToEliminate.insert(candidate);
}
return varsToEliminate;
}
void eliminateVariables(
Dialect const& _dialect,
2022-03-15 17:10:52 +00:00
Block& _ast,
std::map<YulString, int> const& _numVariables,
bool _allowMSizeOptimization
)
{
RematCandidateSelector selector{_dialect};
2022-03-15 17:10:52 +00:00
selector(_ast);
std::map<YulString, std::map<size_t, std::vector<YulString>>> candidates = selector.candidates();
2022-03-15 17:10:52 +00:00
std::set<YulString> varsToEliminate;
2022-03-15 17:10:52 +00:00
for (auto const& [functionName, numVariables]: _numVariables)
{
yulAssert(numVariables > 0);
varsToEliminate += chooseVarsToEliminate(candidates[functionName], static_cast<size_t>(numVariables));
}
2022-08-23 17:28:45 +00:00
Rematerialiser::run(_dialect, _ast, std::move(varsToEliminate));
2022-03-15 17:10:52 +00:00
// Do not remove functions.
std::set<YulString> allFunctions = NameCollector{_ast, NameCollector::OnlyFunctions}.names();
2022-03-15 17:10:52 +00:00
UnusedPruner::runUntilStabilised(_dialect, _ast, _allowMSizeOptimization, nullptr, allFunctions);
2019-02-04 16:30:29 +00:00
}
2022-03-15 17:10:52 +00:00
void eliminateVariablesOptimizedCodegen(
Dialect const& _dialect,
2022-03-15 17:10:52 +00:00
Block& _ast,
std::map<YulString, std::vector<StackLayoutGenerator::StackTooDeep>> const& _unreachables,
bool _allowMSizeOptimization
)
{
2022-03-15 17:10:52 +00:00
if (std::all_of(_unreachables.begin(), _unreachables.end(), [](auto const& _item) { return _item.second.empty(); }))
return;
RematCandidateSelector selector{_dialect};
2022-03-15 17:10:52 +00:00
selector(_ast);
std::map<YulString, size_t> candidates;
2022-03-15 17:10:52 +00:00
for (auto const& [functionName, candidatesInFunction]: selector.candidates())
for (auto [cost, candidatesWithCost]: candidatesInFunction)
for (auto candidate: candidatesWithCost)
2022-03-16 15:43:21 +00:00
candidates[candidate] = cost;
std::set<YulString> varsToEliminate;
// TODO: this currently ignores the fact that variables may reference other variables we want to eliminate.
2022-03-15 17:10:52 +00:00
for (auto const& [functionName, unreachables]: _unreachables)
for (auto const& unreachable: unreachables)
{
std::map<size_t, std::vector<YulString>> suitableCandidates;
2022-03-15 17:10:52 +00:00
size_t neededSlots = unreachable.deficit;
for (auto varName: unreachable.variableChoices)
{
if (varsToEliminate.count(varName))
--neededSlots;
else if (size_t* cost = util::valueOrNullptr(candidates, varName))
if (!util::contains(suitableCandidates[*cost], varName))
suitableCandidates[*cost].emplace_back(varName);
}
for (auto candidatesByCost: suitableCandidates)
{
for (auto candidate: candidatesByCost.second)
if (neededSlots--)
varsToEliminate.emplace(candidate);
else
break;
if (!neededSlots)
break;
2022-03-15 17:10:52 +00:00
}
}
2022-03-15 17:10:52 +00:00
Rematerialiser::run(_dialect, _ast, std::move(varsToEliminate), true);
// Do not remove functions.
std::set<YulString> allFunctions = NameCollector{_ast, NameCollector::OnlyFunctions}.names();
2022-03-15 17:10:52 +00:00
UnusedPruner::runUntilStabilised(_dialect, _ast, _allowMSizeOptimization, nullptr, allFunctions);
}
2019-02-04 16:30:29 +00:00
}
bool StackCompressor::run(
Dialect const& _dialect,
Object& _object,
bool _optimizeStackAllocation,
size_t _maxIterations
)
2019-02-04 16:30:29 +00:00
{
yulAssert(
_object.code &&
_object.code->statements.size() > 0 && std::holds_alternative<Block>(_object.code->statements.at(0)),
2019-02-04 16:30:29 +00:00
"Need to run the function grouper before the stack compressor."
);
bool usesOptimizedCodeGenerator = false;
if (auto evmDialect = dynamic_cast<EVMDialect const*>(&_dialect))
usesOptimizedCodeGenerator =
_optimizeStackAllocation &&
evmDialect->evmVersion().canOverchargeGasForCall() &&
evmDialect->providesObjectAccess();
bool allowMSizeOptimzation = !MSizeFinder::containsMSize(_dialect, *_object.code);
if (usesOptimizedCodeGenerator)
2019-02-04 16:30:29 +00:00
{
yul::AsmAnalysisInfo analysisInfo = yul::AsmAnalyzer::analyzeStrictAssertCorrect(_dialect, _object);
std::unique_ptr<CFG> cfg = ControlFlowGraphBuilder::build(analysisInfo, _dialect, *_object.code);
2022-03-15 17:10:52 +00:00
eliminateVariablesOptimizedCodegen(
_dialect,
*_object.code,
StackLayoutGenerator::reportStackTooDeep(*cfg),
allowMSizeOptimzation
);
2019-02-04 16:30:29 +00:00
}
else
for (size_t iterations = 0; iterations < _maxIterations; iterations++)
{
std::map<YulString, int> stackSurplus = CompilabilityChecker(_dialect, _object, _optimizeStackAllocation).stackDeficit;
if (stackSurplus.empty())
return true;
2022-03-15 17:10:52 +00:00
eliminateVariables(
_dialect,
*_object.code,
stackSurplus,
allowMSizeOptimzation
);
}
2019-02-04 16:30:29 +00:00
return false;
}