solidity/libyul/optimiser/Suite.cpp

399 lines
11 KiB
C++
Raw Normal View History

2018-10-16 19:39:22 +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/>.
*/
/**
* Optimiser suite that combines all steps and also provides the settings for the heuristics.
*/
#include <libyul/optimiser/Suite.h>
#include <libyul/optimiser/Disambiguator.h>
2018-12-13 14:26:01 +00:00
#include <libyul/optimiser/VarDeclInitializer.h>
2019-01-08 14:19:35 +00:00
#include <libyul/optimiser/BlockFlattener.h>
#include <libyul/optimiser/CallGraphGenerator.h>
2019-05-09 19:56:56 +00:00
#include <libyul/optimiser/ControlFlowSimplifier.h>
2019-09-11 09:42:59 +00:00
#include <libyul/optimiser/ConditionalSimplifier.h>
2019-10-07 08:06:00 +00:00
#include <libyul/optimiser/ConditionalUnsimplifier.h>
2019-03-28 13:18:17 +00:00
#include <libyul/optimiser/DeadCodeEliminator.h>
2018-10-16 19:39:22 +00:00
#include <libyul/optimiser/FunctionGrouper.h>
#include <libyul/optimiser/FunctionHoister.h>
#include <libyul/optimiser/EquivalentFunctionCombiner.h>
2018-10-16 19:39:22 +00:00
#include <libyul/optimiser/ExpressionSplitter.h>
#include <libyul/optimiser/ExpressionJoiner.h>
#include <libyul/optimiser/ExpressionInliner.h>
#include <libyul/optimiser/FullInliner.h>
#include <libyul/optimiser/ForLoopConditionIntoBody.h>
2019-09-11 16:55:31 +00:00
#include <libyul/optimiser/ForLoopConditionOutOfBody.h>
#include <libyul/optimiser/ForLoopInitRewriter.h>
2019-09-11 09:42:59 +00:00
#include <libyul/optimiser/ForLoopConditionIntoBody.h>
2018-10-16 19:39:22 +00:00
#include <libyul/optimiser/Rematerialiser.h>
#include <libyul/optimiser/UnusedPruner.h>
#include <libyul/optimiser/ExpressionSimplifier.h>
#include <libyul/optimiser/CommonSubexpressionEliminator.h>
#include <libyul/optimiser/Semantics.h>
2019-01-16 10:44:45 +00:00
#include <libyul/optimiser/SSAReverser.h>
2018-10-16 19:39:22 +00:00
#include <libyul/optimiser/SSATransform.h>
2019-02-04 16:30:29 +00:00
#include <libyul/optimiser/StackCompressor.h>
#include <libyul/optimiser/StructuralSimplifier.h>
2019-10-07 06:16:28 +00:00
#include <libyul/optimiser/SyntacticalEquality.h>
2018-10-16 19:39:22 +00:00
#include <libyul/optimiser/RedundantAssignEliminator.h>
#include <libyul/optimiser/VarNameCleaner.h>
2019-08-29 14:43:06 +00:00
#include <libyul/optimiser/LoadResolver.h>
#include <libyul/optimiser/LoopInvariantCodeMotion.h>
#include <libyul/optimiser/Metrics.h>
2019-05-28 10:57:15 +00:00
#include <libyul/backends/evm/ConstantOptimiser.h>
#include <libyul/AsmAnalysis.h>
#include <libyul/AsmAnalysisInfo.h>
#include <libyul/AsmData.h>
#include <libyul/AsmPrinter.h>
#include <libyul/Object.h>
2018-10-16 19:39:22 +00:00
2019-05-09 15:56:25 +00:00
#include <libyul/backends/wasm/WasmDialect.h>
#include <libyul/backends/evm/NoOutputAssembly.h>
2018-10-16 19:39:22 +00:00
#include <libdevcore/CommonData.h>
using namespace std;
using namespace dev;
using namespace yul;
2018-10-16 19:39:22 +00:00
void OptimiserSuite::run(
Dialect const& _dialect,
2019-05-29 21:14:06 +00:00
GasMeter const* _meter,
Object& _object,
bool _optimizeStackAllocation,
set<YulString> const& _externallyUsedIdentifiers
2018-10-16 19:39:22 +00:00
)
{
set<YulString> reservedIdentifiers = _externallyUsedIdentifiers;
2019-05-29 21:14:06 +00:00
reservedIdentifiers += _dialect.fixedFunctionNames();
2018-10-16 19:39:22 +00:00
*_object.code = std::get<Block>(Disambiguator(
_dialect,
*_object.analysisInfo,
reservedIdentifiers
)(*_object.code));
Block& ast = *_object.code;
2018-10-16 19:39:22 +00:00
2019-09-23 14:32:50 +00:00
OptimiserSuite suite(_dialect, reservedIdentifiers, Debug::None, ast);
suite.runSequence({
VarDeclInitializer::name,
FunctionHoister::name,
BlockFlattener::name,
ForLoopInitRewriter::name,
DeadCodeEliminator::name,
FunctionGrouper::name,
EquivalentFunctionCombiner::name,
UnusedPruner::name,
BlockFlattener::name,
ControlFlowSimplifier::name,
LiteralRematerialiser::name,
2019-10-07 08:06:00 +00:00
ConditionalUnsimplifier::name,
2019-09-23 14:32:50 +00:00
StructuralSimplifier::name,
ControlFlowSimplifier::name,
ForLoopConditionIntoBody::name,
BlockFlattener::name
}, ast);
// None of the above can make stack problems worse.
2018-10-16 19:39:22 +00:00
size_t codeSize = 0;
for (size_t rounds = 0; rounds < 12; ++rounds)
2018-10-16 19:39:22 +00:00
{
{
size_t newSize = CodeSize::codeSizeIncludingFunctions(ast);
if (newSize == codeSize)
break;
codeSize = newSize;
}
{
// Turn into SSA and simplify
2019-09-23 14:32:50 +00:00
suite.runSequence({
ExpressionSplitter::name,
SSATransform::name,
RedundantAssignEliminator::name,
RedundantAssignEliminator::name,
ExpressionSimplifier::name,
CommonSubexpressionEliminator::name,
LoadResolver::name,
LoopInvariantCodeMotion::name
2019-09-23 14:32:50 +00:00
}, ast);
}
{
2019-09-11 09:42:59 +00:00
// perform structural simplification
2019-09-23 14:32:50 +00:00
suite.runSequence({
2019-09-11 09:42:59 +00:00
CommonSubexpressionEliminator::name,
ConditionalSimplifier::name,
2019-09-23 14:32:50 +00:00
LiteralRematerialiser::name,
2019-10-07 08:06:00 +00:00
ConditionalUnsimplifier::name,
2019-09-11 09:42:59 +00:00
StructuralSimplifier::name,
LiteralRematerialiser::name,
2019-09-23 14:32:50 +00:00
ForLoopConditionOutOfBody::name,
ControlFlowSimplifier::name,
StructuralSimplifier::name,
ControlFlowSimplifier::name,
BlockFlattener::name,
DeadCodeEliminator::name,
ForLoopConditionIntoBody::name,
UnusedPruner::name
}, ast);
}
{
// simplify again
2019-09-23 14:32:50 +00:00
suite.runSequence({
LoadResolver::name,
CommonSubexpressionEliminator::name,
UnusedPruner::name,
}, ast);
}
{
// reverse SSA
2019-09-23 14:32:50 +00:00
suite.runSequence({
SSAReverser::name,
CommonSubexpressionEliminator::name,
UnusedPruner::name,
ExpressionJoiner::name,
ExpressionJoiner::name,
}, ast);
}
// should have good "compilability" property here.
{
// run functional expression inliner
2019-09-23 14:32:50 +00:00
suite.runSequence({
ExpressionInliner::name,
UnusedPruner::name,
}, ast);
}
2019-11-27 10:51:06 +00:00
{
// Prune a bit more in SSA
suite.runSequence({
ExpressionSplitter::name,
SSATransform::name,
RedundantAssignEliminator::name,
UnusedPruner::name,
RedundantAssignEliminator::name,
UnusedPruner::name,
}, ast);
}
{
// Turn into SSA again and simplify
2019-09-23 14:32:50 +00:00
suite.runSequence({
ExpressionSplitter::name,
SSATransform::name,
RedundantAssignEliminator::name,
RedundantAssignEliminator::name,
CommonSubexpressionEliminator::name,
LoadResolver::name,
}, ast);
}
{
// run full inliner
2019-09-23 14:32:50 +00:00
suite.runSequence({
FunctionGrouper::name,
EquivalentFunctionCombiner::name,
FullInliner::name,
BlockFlattener::name
}, ast);
}
{
// SSA plus simplify
2019-09-23 14:32:50 +00:00
suite.runSequence({
2019-09-11 09:42:59 +00:00
ConditionalSimplifier::name,
2019-10-07 08:06:00 +00:00
LiteralRematerialiser::name,
ConditionalUnsimplifier::name,
2019-09-11 09:42:59 +00:00
CommonSubexpressionEliminator::name,
2019-09-23 14:32:50 +00:00
SSATransform::name,
RedundantAssignEliminator::name,
RedundantAssignEliminator::name,
LoadResolver::name,
ExpressionSimplifier::name,
LiteralRematerialiser::name,
2019-09-23 14:32:50 +00:00
ForLoopConditionOutOfBody::name,
StructuralSimplifier::name,
BlockFlattener::name,
DeadCodeEliminator::name,
ControlFlowSimplifier::name,
CommonSubexpressionEliminator::name,
SSATransform::name,
RedundantAssignEliminator::name,
RedundantAssignEliminator::name,
ForLoopConditionIntoBody::name,
UnusedPruner::name,
CommonSubexpressionEliminator::name,
}, ast);
}
2018-10-16 19:39:22 +00:00
}
// Make source short and pretty.
2019-09-23 14:32:50 +00:00
suite.runSequence({
ExpressionJoiner::name,
Rematerialiser::name,
UnusedPruner::name,
ExpressionJoiner::name,
UnusedPruner::name,
ExpressionJoiner::name,
UnusedPruner::name,
SSAReverser::name,
CommonSubexpressionEliminator::name,
LiteralRematerialiser::name,
ForLoopConditionOutOfBody::name,
CommonSubexpressionEliminator::name,
UnusedPruner::name,
ExpressionJoiner::name,
Rematerialiser::name,
UnusedPruner::name,
}, ast);
2018-10-16 19:39:22 +00:00
// This is a tuning parameter, but actually just prevents infinite loops.
size_t stackCompressorMaxIterations = 16;
2019-09-23 14:32:50 +00:00
suite.runSequence({
FunctionGrouper::name
}, ast);
// We ignore the return value because we will get a much better error
// message once we perform code generation.
StackCompressor::run(
_dialect,
_object,
_optimizeStackAllocation,
stackCompressorMaxIterations
);
2019-09-23 14:32:50 +00:00
suite.runSequence({
BlockFlattener::name,
DeadCodeEliminator::name,
ControlFlowSimplifier::name,
LiteralRematerialiser::name,
ForLoopConditionOutOfBody::name,
CommonSubexpressionEliminator::name,
2019-09-23 14:32:50 +00:00
FunctionGrouper::name,
}, ast);
2019-05-15 08:33:35 +00:00
2019-05-28 10:57:15 +00:00
if (EVMDialect const* dialect = dynamic_cast<EVMDialect const*>(&_dialect))
2019-05-29 21:14:06 +00:00
{
yulAssert(_meter, "");
ConstantOptimiser{*dialect, *_meter}(ast);
}
2019-05-09 15:56:25 +00:00
else if (dynamic_cast<WasmDialect const*>(&_dialect))
{
// If the first statement is an empty block, remove it.
// We should only have function definitions after that.
if (ast.statements.size() > 1 && std::get<Block>(ast.statements.front()).statements.empty())
2019-05-09 15:56:25 +00:00
ast.statements.erase(ast.statements.begin());
}
2019-09-23 14:32:50 +00:00
suite.runSequence({
VarNameCleaner::name
}, ast);
2019-02-04 16:30:29 +00:00
*_object.analysisInfo = AsmAnalyzer::analyzeStrictAssertCorrect(_dialect, _object);
2018-10-16 19:39:22 +00:00
}
2019-09-23 14:32:50 +00:00
namespace
{
template <class... Step>
map<string, unique_ptr<OptimiserStep>> optimiserStepCollection()
{
map<string, unique_ptr<OptimiserStep>> ret;
for (unique_ptr<OptimiserStep>& s: make_vector<unique_ptr<OptimiserStep>>(
(make_unique<OptimiserStepInstance<Step>>())...
))
{
yulAssert(!ret.count(s->name), "");
ret[s->name] = std::move(s);
}
return ret;
}
}
map<string, unique_ptr<OptimiserStep>> const& OptimiserSuite::allSteps()
{
static map<string, unique_ptr<OptimiserStep>> instance;
if (instance.empty())
instance = optimiserStepCollection<
BlockFlattener,
CommonSubexpressionEliminator,
2019-09-11 09:42:59 +00:00
ConditionalSimplifier,
2019-10-07 08:06:00 +00:00
ConditionalUnsimplifier,
2019-09-23 14:32:50 +00:00
ControlFlowSimplifier,
DeadCodeEliminator,
EquivalentFunctionCombiner,
ExpressionInliner,
ExpressionJoiner,
ExpressionSimplifier,
ExpressionSplitter,
ForLoopConditionIntoBody,
ForLoopConditionOutOfBody,
ForLoopInitRewriter,
FullInliner,
FunctionGrouper,
FunctionHoister,
LiteralRematerialiser,
LoadResolver,
LoopInvariantCodeMotion,
2019-09-23 14:32:50 +00:00
RedundantAssignEliminator,
Rematerialiser,
SSAReverser,
SSATransform,
StructuralSimplifier,
UnusedPruner,
VarDeclInitializer,
VarNameCleaner
>();
return instance;
}
void OptimiserSuite::runSequence(std::vector<string> const& _steps, Block& _ast)
{
2019-10-07 06:16:28 +00:00
unique_ptr<Block> copy;
if (m_debug == Debug::PrintChanges)
copy = make_unique<Block>(std::get<Block>(ASTCopier{}(_ast)));
2019-09-23 14:32:50 +00:00
for (string const& step: _steps)
{
if (m_debug == Debug::PrintStep)
cout << "Running " << step << endl;
allSteps().at(step)->run(m_context, _ast);
2019-10-07 06:16:28 +00:00
if (m_debug == Debug::PrintChanges)
{
// TODO should add switch to also compare variable names!
if (SyntacticallyEqual{}.statementEqual(_ast, *copy))
cout << "== Running " << step << " did not cause changes." << endl;
else
{
cout << "== Running " << step << " changed the AST." << endl;
cout << AsmPrinter{}(_ast) << endl;
copy = make_unique<Block>(std::get<Block>(ASTCopier{}(_ast)));
2019-10-07 06:16:28 +00:00
}
}
2019-09-23 14:32:50 +00:00
}
}