cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Stack compressor.

Browse Source
This commit is contained in:
chriseth 2019-02-04 17:30:29 +01:00
parent 5a34743d88
commit 83083d2208
12 changed files with 282 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libyul/CMakeLists.txt
View File

@ -94,6 +94,8 @@ add_library(yul
optimiser/Semantics.h
optimiser/SimplificationRules.cpp
optimiser/SimplificationRules.h
optimiser/StackCompressor.cpp
optimiser/StackCompressor.h
optimiser/StructuralSimplifier.cpp
optimiser/StructuralSimplifier.h
optimiser/Substitution.cpp

32
libyul/optimiser/Rematerialiser.cpp
View File

@ -30,25 +30,39 @@ using namespace std;
using namespace dev;
using namespace yul;
void Rematerialiser::run(Dialect const& _dialect, Block& _ast)
void Rematerialiser::run(Dialect const& _dialect, Block& _ast, set<YulString> _varsToAlwaysRematerialize)
{
Rematerialiser{_dialect, _ast}(_ast);
Rematerialiser{_dialect, _ast, std::move(_varsToAlwaysRematerialize)}(_ast);
}
void Rematerialiser::run(Dialect const& _dialect, FunctionDefinition& _function)
void Rematerialiser::run(
Dialect const& _dialect,
FunctionDefinition& _function,
set<YulString> _varsToAlwaysRematerialize
)
{
Rematerialiser{_dialect, _function}(_function);
Rematerialiser{_dialect, _function, std::move(_varsToAlwaysRematerialize)}(_function);
}
Rematerialiser::Rematerialiser(Dialect const& _dialect, Block& _ast):
Rematerialiser::Rematerialiser(
Dialect const& _dialect,
Block& _ast,
set<YulString> _varsToAlwaysRematerialize
):
DataFlowAnalyzer(_dialect),
m_referenceCounts(ReferencesCounter::countReferences(_ast))
m_referenceCounts(ReferencesCounter::countReferences(_ast)),
m_varsToAlwaysRematerialize(std::move(_varsToAlwaysRematerialize))
{
}
Rematerialiser::Rematerialiser(Dialect const& _dialect, FunctionDefinition& _function):
Rematerialiser::Rematerialiser(
Dialect const& _dialect,
FunctionDefinition& _function,
set<YulString> _varsToAlwaysRematerialize
):
DataFlowAnalyzer(_dialect),
m_referenceCounts(ReferencesCounter::countReferences(_function))
m_referenceCounts(ReferencesCounter::countReferences(_function)),
m_varsToAlwaysRematerialize(std::move(_varsToAlwaysRematerialize))
{
}
@ -64,7 +78,7 @@ void Rematerialiser::visit(Expression& _e)
auto const& value = *m_value.at(name);
size_t refs = m_referenceCounts[name];
size_t cost = CodeCost::codeCost(value);
if (refs <= 1 || cost == 0 || (refs <= 5 && cost <= 1))
if (refs <= 1 || cost == 0 || (refs <= 5 && cost <= 1) || m_varsToAlwaysRematerialize.count(name))
{
assertThrow(m_referenceCounts[name] > 0, OptimizerException, "");
for (auto const& ref: m_references[name])

25
libyul/optimiser/Rematerialiser.h
View File

@ -38,17 +38,34 @@ namespace yul
class Rematerialiser: public DataFlowAnalyzer
{
public:
static void run(Dialect const& _dialect, Block& _ast);
static void run(Dialect const& _dialect, FunctionDefinition& _function);
static void run(
Dialect const& _dialect,
Block& _ast,
std::set<YulString> _varsToAlwaysRematerialize = {}
);
static void run(
Dialect const& _dialect,
FunctionDefinition& _function,
std::set<YulString> _varsToAlwaysRematerialize = {}
);
protected:
Rematerialiser(Dialect const& _dialect, Block& _ast);
Rematerialiser(Dialect const& _dialect, FunctionDefinition& _function);
Rematerialiser(
Dialect const& _dialect,
Block& _ast,
std::set<YulString> _varsToAlwaysRematerialize = {}
);
Rematerialiser(
Dialect const& _dialect,
FunctionDefinition& _function,
std::set<YulString> _varsToAlwaysRematerialize = {}
);
using ASTModifier::visit;
void visit(Expression& _e) override;
std::map<YulString, size_t> m_referenceCounts;
std::set<YulString> m_varsToAlwaysRematerialize;
};
}

107
libyul/optimiser/StackCompressor.cpp Normal file
View File

@ -0,0 +1,107 @@
/*(
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/SSAValueTracker.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/CompilabilityChecker.h>
#include <libyul/AsmData.h>
using namespace std;
using namespace dev;
using namespace yul;
namespace
{
template <typename ASTNode>
void eliminateVariables(shared_ptr<Dialect> const& _dialect, ASTNode& _node, size_t _numVariables)
{
SSAValueTracker ssaValues;
ssaValues(_node);
map<YulString, size_t> references = ReferencesCounter::countReferences(_node);
set<pair<size_t, YulString>> rematCosts;
for (auto const& ssa: ssaValues.values())
{
if (!MovableChecker{*_dialect, *ssa.second}.movable())
continue;
size_t numRef = references[ssa.first];
size_t cost = 0;
if (numRef > 1)
cost = CodeCost::codeCost(*ssa.second) * (numRef - 1);
rematCosts.insert(make_pair(cost, ssa.first));
}
// Select at most _numVariables
set<YulString> varsToEliminate;
for (auto const& costs: rematCosts)
{
if (varsToEliminate.size() >= _numVariables)
break;
varsToEliminate.insert(costs.second);
}
Rematerialiser::run(*_dialect, _node, std::move(varsToEliminate));
UnusedPruner::runUntilStabilised(*_dialect, _node);
}
}
bool StackCompressor::run(shared_ptr<Dialect> const& _dialect, Block& _ast)
{
yulAssert(
_ast.statements.size() > 0 && _ast.statements.at(0).type() == typeid(Block),
"Need to run the function grouper before the stack compressor."
);
for (size_t iterations = 0; iterations < 4; iterations++)
{
map<YulString, int> stackSurplus = CompilabilityChecker::run(_dialect, _ast);
if (stackSurplus.empty())
return true;
if (stackSurplus.count(YulString{}))
{
yulAssert(stackSurplus.at({}) > 0, "Invalid surplus value.");
eliminateVariables(_dialect, boost::get<Block>(_ast.statements.at(0)), stackSurplus.at({}));
}
for (size_t i = 1; i < _ast.statements.size(); ++i)
{
FunctionDefinition& fun = boost::get<FunctionDefinition>(_ast.statements[i]);
if (!stackSurplus.count(fun.name))
continue;
yulAssert(stackSurplus.at(fun.name) > 0, "Invalid surplus value.");
eliminateVariables(_dialect, fun, stackSurplus.at(fun.name));
}
}
return false;
}

47
libyul/optimiser/StackCompressor.h Normal file
View File

@ -0,0 +1,47 @@
/*
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.
*/
#pragma once
#include <memory>
namespace yul
{
struct Dialect;
struct Block;
struct FunctionDefinition;
/**
* Optimisation stage that aggressively rematerializes certain variables in a function to free
* space on the stack until it is compilable.
*
* Prerequisite: Disambiguator, Function Grouper
*/
class StackCompressor
{
public:
/// Try to remove local variables until the AST is compilable.
/// @returns true if it was successful.
static bool run(std::shared_ptr<Dialect> const& _dialect, Block& _ast);
};
}

5
libyul/optimiser/Suite.cpp
View File

@ -37,6 +37,7 @@
#include <libyul/optimiser/CommonSubexpressionEliminator.h>
#include <libyul/optimiser/SSAReverser.h>
#include <libyul/optimiser/SSATransform.h>
#include <libyul/optimiser/StackCompressor.h>
#include <libyul/optimiser/StructuralSimplifier.h>
#include <libyul/optimiser/RedundantAssignEliminator.h>
#include <libyul/AsmAnalysisInfo.h>
@ -170,5 +171,9 @@ void OptimiserSuite::run(
Rematerialiser::run(*_dialect, ast);
UnusedPruner::runUntilStabilised(*_dialect, ast, reservedIdentifiers);
(FunctionGrouper{})(ast);
StackCompressor::run(_dialect, ast);
(BlockFlattener{})(ast);
_ast = std::move(ast);
}

8
test/libyul/YulOptimizerTest.cpp
View File

@ -42,6 +42,7 @@
#include <libyul/optimiser/SSATransform.h>
#include <libyul/optimiser/RedundantAssignEliminator.h>
#include <libyul/optimiser/StructuralSimplifier.h>
#include <libyul/optimiser/StackCompressor.h>
#include <libyul/optimiser/Suite.h>
#include <libyul/backends/evm/EVMDialect.h>
#include <libyul/AsmPrinter.h>
@ -241,6 +242,13 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
CommonSubexpressionEliminator{*m_dialect}(*m_ast);
UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
}
else if (m_optimizerStep == "stackCompressor")
{
disambiguate();
(FunctionGrouper{})(*m_ast);
StackCompressor::run(m_dialect, *m_ast);
(BlockFlattener{})(*m_ast);
}
else if (m_optimizerStep == "fullSuite")
OptimiserSuite::run(m_dialect, *m_ast, *m_analysisInfo);
else

59
test/libyul/yulOptimizerTests/fullSuite/aztec.yul
View File

@ -234,10 +234,8 @@
// let validateJo__6 := 0x80
// mstore(validateJo__6, 7673901602397024137095011250362199966051872585513276903826533215767972925880)
// mstore(0xa0, 8489654445897228341090914135473290831551238522473825886865492707826370766375)
// let validateJo__10 := calldataload(0x04)
// let validateJo_notes := add(0x04, validateJo__10)
// let validateJo_m := calldataload(0x24)
// let validateJo_n := calldataload(validateJo_notes)
// let validateJo_n := calldataload(add(0x04, calldataload(0x04)))
// let validateJo_gen_order := 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
// let validateJo_challenge := mod(calldataload(0x44), validateJo_gen_order)
// if gt(validateJo_m, validateJo_n)
@ -246,12 +244,11 @@
// revert(0x00, 0x20)
// }
// let validateJo_kn := calldataload(add(calldatasize(), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff40))
// let validateJo__24 := 0x2a0
// mstore(validateJo__24, caller())
// mstore(0x2a0, caller())
// mstore(0x2c0, validateJo_kn)
// mstore(0x2e0, validateJo_m)
// validateJo_kn := mulmod(sub(validateJo_gen_order, validateJo_kn), validateJo_challenge, validateJo_gen_order)
// hashCommitments(validateJo_notes, validateJo_n)
// hashCommitments(add(0x04, calldataload(0x04)), validateJo_n)
// let validateJo_b := add(0x300, mul(validateJo_n, validateJo__6))
// let validateJo_i := 0
// let validateJo_i_1218 := validateJo_i
@ -262,14 +259,11 @@
// validateJo_i := add(validateJo_i, 0x01)
// }
// {
// let validateJo__34 := 0x20
// let validateJo__329 := add(validateJo__10, mul(validateJo_i, 0xc0))
// let validateJo_noteIndex := add(validateJo__329, 0x24)
// let validateJo__329 := add(calldataload(0x04), mul(validateJo_i, 0xc0))
// let validateJo_k := validateJo_i_1218
// let validateJo_a := calldataload(add(validateJo__329, 0x44))
// let validateJo_c := validateJo_challenge
// let validateJo__39 := add(validateJo_i, 0x01)
// switch eq(validateJo__39, validateJo_n)
// switch eq(add(validateJo_i, 0x01), validateJo_n)
// case 1 {
// validateJo_k := validateJo_kn
// if eq(validateJo_m, validateJo_n)
@ -278,55 +272,50 @@
// }
// }
// case 0 {
// validateJo_k := calldataload(validateJo_noteIndex)
// validateJo_k := calldataload(add(validateJo__329, 0x24))
// }
// validateCommitment(validateJo_noteIndex, validateJo_k, validateJo_a)
// switch gt(validateJo__39, validateJo_m)
// validateCommitment(add(validateJo__329, 0x24), validateJo_k, validateJo_a)
// switch gt(add(validateJo_i, 0x01), validateJo_m)
// case 1 {
// validateJo_kn := addmod(validateJo_kn, sub(validateJo_gen_order, validateJo_k), validateJo_gen_order)
// let validateJo_x := mod(mload(validateJo_i_1218), validateJo_gen_order)
// validateJo_k := mulmod(validateJo_k, validateJo_x, validateJo_gen_order)
// validateJo_a := mulmod(validateJo_a, validateJo_x, validateJo_gen_order)
// validateJo_c := mulmod(validateJo_challenge, validateJo_x, validateJo_gen_order)
// mstore(validateJo_i_1218, keccak256(validateJo_i_1218, validateJo__34))
// mstore(validateJo_i_1218, keccak256(validateJo_i_1218, 0x20))
// }
// case 0 {
// validateJo_kn := addmod(validateJo_kn, validateJo_k, validateJo_gen_order)
// }
// let validateJo__52 := 0x40
// calldatacopy(0xe0, add(validateJo__329, 164), validateJo__52)
// calldatacopy(validateJo__34, add(validateJo__329, 100), validateJo__52)
// let validateJo__61 := 0x120
// mstore(validateJo__61, sub(validateJo_gen_order, validateJo_c))
// let validateJo__62 := 0x60
// mstore(validateJo__62, validateJo_k)
// calldatacopy(0x20, add(validateJo__329, 100), validateJo__52)
// mstore(0x120, sub(validateJo_gen_order, validateJo_c))
// mstore(0x60, validateJo_k)
// mstore(0xc0, validateJo_a)
// let validateJo__65 := 0x1a0
// let validateJo_result := call(gas(), 7, validateJo_i_1218, 0xe0, validateJo__62, validateJo__65, validateJo__52)
// let validateJo_result_303 := and(validateJo_result, call(gas(), 7, validateJo_i_1218, validateJo__34, validateJo__62, validateJo__61, validateJo__52))
// let validateJo__80 := 0x160
// let validateJo_result_304 := and(validateJo_result_303, call(gas(), 7, validateJo_i_1218, validateJo__6, validateJo__62, validateJo__80, validateJo__52))
// let validateJo_result_305 := and(validateJo_result_304, call(gas(), 6, validateJo_i_1218, validateJo__61, validateJo__6, validateJo__80, validateJo__52))
// validateJo_result := and(validateJo_result_305, call(gas(), 6, validateJo_i_1218, validateJo__80, validateJo__6, validateJo_b, validateJo__52))
// let validateJo_result := call(gas(), 7, validateJo_i_1218, 0xe0, 0x60, 0x1a0, validateJo__52)
// let validateJo_result_303 := and(validateJo_result, call(gas(), 7, validateJo_i_1218, 0x20, 0x60, 0x120, validateJo__52))
// let validateJo_result_304 := and(validateJo_result_303, call(gas(), 7, validateJo_i_1218, validateJo__6, 0x60, 0x160, validateJo__52))
// let validateJo_result_305 := and(validateJo_result_304, call(gas(), 6, validateJo_i_1218, 0x120, validateJo__6, 0x160, validateJo__52))
// validateJo_result := and(validateJo_result_305, call(gas(), 6, validateJo_i_1218, 0x160, validateJo__6, validateJo_b, validateJo__52))
// if eq(validateJo_i, validateJo_m)
// {
// mstore(0x260, mload(validateJo__34))
// mstore(0x260, mload(0x20))
// mstore(0x280, mload(validateJo__52))
// mstore(0x1e0, mload(0xe0))
// mstore(0x200, sub(0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47, mload(0x100)))
// }
// if gt(validateJo_i, validateJo_m)
// {
// mstore(validateJo__62, validateJo_c)
// let validateJo__120 := 0x220
// let validateJo_result_307 := and(validateJo_result, call(gas(), 7, validateJo_i_1218, validateJo__34, validateJo__62, validateJo__120, validateJo__52))
// let validateJo_result_308 := and(validateJo_result_307, call(gas(), 6, validateJo_i_1218, validateJo__120, validateJo__6, 0x260, validateJo__52))
// validateJo_result := and(validateJo_result_308, call(gas(), 6, validateJo_i_1218, validateJo__65, validateJo__6, 0x1e0, validateJo__52))
// mstore(0x60, validateJo_c)
// let validateJo_result_307 := and(validateJo_result, call(gas(), 7, validateJo_i_1218, 0x20, 0x60, 0x220, validateJo__52))
// let validateJo_result_308 := and(validateJo_result_307, call(gas(), 6, validateJo_i_1218, 0x220, validateJo__6, 0x260, validateJo__52))
// validateJo_result := and(validateJo_result_308, call(gas(), 6, validateJo_i_1218, 0x1a0, validateJo__6, 0x1e0, validateJo__52))
// }
// if iszero(validateJo_result)
// {
// mstore(validateJo_i_1218, 400)
// revert(validateJo_i_1218, validateJo__34)
// revert(validateJo_i_1218, 0x20)
// }
// validateJo_b := add(validateJo_b, validateJo__52)
// }
@ -334,7 +323,7 @@
// {
// validatePairing(0x64)
// }
// if iszero(eq(mod(keccak256(validateJo__24, add(validateJo_b, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd60)), validateJo_gen_order), validateJo_challenge))
// if iszero(eq(mod(keccak256(0x2a0, add(validateJo_b, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd60)), validateJo_gen_order), validateJo_challenge))
// {
// mstore(validateJo_i_1218, 404)
// revert(validateJo_i_1218, 0x20)

10
test/libyul/yulOptimizerTests/stackCompressor/inlineInBlock.yul Normal file
View File

@ -0,0 +1,10 @@
{
let x := 8
let y := calldataload(calldataload(9))
mstore(y, add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(y, 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1))
}
// ----
// stackCompressor
// {
// mstore(calldataload(calldataload(9)), add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(calldataload(calldataload(9)), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1))
// }

16
test/libyul/yulOptimizerTests/stackCompressor/inlineInFunction.yul Normal file
View File

@ -0,0 +1,16 @@
{
let x := 8
function f() {
let y := calldataload(calldataload(9))
mstore(y, add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(y, 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1))
}
}
// ----
// stackCompressor
// {
// let x := 8
// function f()
// {
// mstore(calldataload(calldataload(9)), add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(add(calldataload(calldataload(9)), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1), 1))
// }
// }

13
test/libyul/yulOptimizerTests/stackCompressor/noInline.yul Normal file
View File

@ -0,0 +1,13 @@
{
let x := 8
function f() { let y := 9 }
}
// ----
// stackCompressor
// {
// let x := 8
// function f()
// {
// let y := 9
// }
// }

7
test/tools/yulopti.cpp
View File

@ -48,6 +48,7 @@
#include <libyul/optimiser/RedundantAssignEliminator.h>
#include <libyul/optimiser/SSAReverser.h>
#include <libyul/optimiser/SSATransform.h>
#include <libyul/optimiser/StackCompressor.h>
#include <libyul/optimiser/StructuralSimplifier.h>
#include <libyul/optimiser/VarDeclInitializer.h>
@ -130,7 +131,8 @@ public:
cout << "(q)quit/(f)flatten/(c)se/initialize var(d)ecls/(x)plit/(j)oin/(g)rouper/(h)oister/" << endl;
cout << " (e)xpr inline/(i)nline/(s)implify/(u)nusedprune/ss(a) transform/" << endl;
cout << " (r)edundant assign elim./re(m)aterializer/f(o)r-loop-pre-rewriter/" << endl;
cout << " s(t)ructural simplifier/equi(v)alent function combiner/ssa re(V)erser? " << endl;
cout << " s(t)ructural simplifier/equi(v)alent function combiner/ssa re(V)erser/? " << endl;
cout << " stack com(p)ressor? " << endl;
cout.flush();
int option = readStandardInputChar();
cout << ' ' << char(option) << endl;
@ -192,6 +194,9 @@ public:
case 'V':
SSAReverser::run(*m_ast);
break;
case 'p':
StackCompressor::run(m_dialect, *m_ast);
break;
default:
cout << "Unknown option." << endl;
}