solidity/libyul/optimiser/StackLimitEvader.cpp

145 lines
5.3 KiB
C++
Raw Normal View History

2020-07-02 10:48:20 +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/>.
*/
#include <libyul/optimiser/StackLimitEvader.h>
#include <libyul/optimiser/CallGraphGenerator.h>
#include <libyul/optimiser/FunctionCallFinder.h>
#include <libyul/optimiser/NameDispenser.h>
#include <libyul/optimiser/StackToMemoryMover.h>
#include <libyul/backends/evm/EVMDialect.h>
#include <libyul/AsmData.h>
#include <libyul/Dialect.h>
#include <libyul/Exceptions.h>
#include <libyul/Object.h>
#include <libyul/Utilities.h>
#include <libsolutil/Algorithms.h>
#include <libsolutil/CommonData.h>
using namespace std;
using namespace solidity;
using namespace solidity::yul;
namespace
{
2020-09-17 15:25:37 +00:00
/**
* Walks the call graph using a Depth-First-Search assigning memory slots to variables.
* - The leaves of the call graph will get the lowest slot, increasing towards the root.
* - ``slotsRequiredForFunction`` maps a function to the number of slots it requires (which is also the
* next available slot that can be used by another function that calls this function).
* - For each function starting from the root of the call graph:
* - Visit all children that are not already visited.
* - Determine the maximum value ``n`` of the values of ``slotsRequiredForFunction`` among the children.
* - If the function itself contains variables that need memory slots, but is contained in a cycle,
* abort the process as failure.
* - If not, assign each variable its slot starting from ``n`` (incrementing it).
* - Assign ``n`` to ``slotsRequiredForFunction`` of the function.
*/
2020-07-02 10:48:20 +00:00
struct MemoryOffsetAllocator
{
uint64_t run(YulString _function = YulString{})
{
2020-09-17 15:25:37 +00:00
if (slotsRequiredForFunction.count(_function))
return slotsRequiredForFunction[_function];
2020-07-02 10:48:20 +00:00
// Assign to zero early to guard against recursive calls.
2020-09-17 15:25:37 +00:00
slotsRequiredForFunction[_function] = 0;
2020-07-02 10:48:20 +00:00
2020-09-17 15:25:37 +00:00
uint64_t requiredSlots = 0;
2020-07-02 10:48:20 +00:00
if (callGraph.count(_function))
for (YulString child: callGraph.at(_function))
2020-09-17 15:25:37 +00:00
requiredSlots = std::max(run(child), requiredSlots);
2020-07-02 10:48:20 +00:00
if (unreachableVariables.count(_function))
{
yulAssert(!slotAllocations.count(_function), "");
for (YulString variable: unreachableVariables.at(_function))
if (variable.empty())
{
// TODO: Too many function arguments or return parameters.
}
else
slotAllocations[variable] = requiredSlots++;
2020-07-02 10:48:20 +00:00
}
2020-09-17 15:25:37 +00:00
return slotsRequiredForFunction[_function] = requiredSlots;
2020-07-02 10:48:20 +00:00
}
map<YulString, set<YulString>> const& unreachableVariables;
map<YulString, set<YulString>> const& callGraph;
map<YulString, uint64_t> slotAllocations{};
2020-09-17 15:25:37 +00:00
map<YulString, uint64_t> slotsRequiredForFunction{};
2020-07-02 10:48:20 +00:00
};
u256 literalArgumentValue(FunctionCall const& _call)
{
yulAssert(_call.arguments.size() == 1, "");
Literal const* literal = std::get_if<Literal>(&_call.arguments.front());
yulAssert(literal && literal->kind == LiteralKind::Number, "");
return valueOfLiteral(*literal);
}
}
void StackLimitEvader::run(
OptimiserStepContext& _context,
Object& _object,
map<YulString, set<YulString>> const& _unreachableVariables
)
{
yulAssert(_object.code, "");
auto const* evmDialect = dynamic_cast<EVMDialect const*>(&_context.dialect);
yulAssert(
evmDialect && evmDialect->providesObjectAccess(),
"StackLimitEvader can only be run on objects using the EVMDialect with object access."
);
vector<FunctionCall*> memoryGuardCalls = FunctionCallFinder::run(
*_object.code,
"memoryguard"_yulstring
);
// Do not optimise, if no ``memoryguard`` call is found.
if (memoryGuardCalls.empty())
return;
// Make sure all calls to ``memoryguard`` we found have the same value as argument (otherwise, abort).
u256 reservedMemory = literalArgumentValue(*memoryGuardCalls.front());
2020-09-17 15:25:37 +00:00
for (FunctionCall const* memoryGuardCall: memoryGuardCalls)
if (reservedMemory != literalArgumentValue(*memoryGuardCall))
2020-07-02 10:48:20 +00:00
return;
CallGraph callGraph = CallGraphGenerator::callGraph(*_object.code);
// We cannot move variables in recursive functions to fixed memory offsets.
for (YulString function: callGraph.recursiveFunctions())
if (_unreachableVariables.count(function))
return;
MemoryOffsetAllocator memoryOffsetAllocator{_unreachableVariables, callGraph.functionCalls};
uint64_t requiredSlots = memoryOffsetAllocator.run();
StackToMemoryMover::run(_context, reservedMemory, memoryOffsetAllocator.slotAllocations, requiredSlots, *_object.code);
2020-09-17 15:25:37 +00:00
yulAssert(requiredSlots < std::numeric_limits<uint64_t>::max() / 32, "");
2020-07-02 10:48:20 +00:00
reservedMemory += 32 * requiredSlots;
2020-09-17 15:25:37 +00:00
for (FunctionCall* memoryGuardCall: FunctionCallFinder::run(*_object.code, "memoryguard"_yulstring))
2020-07-02 10:48:20 +00:00
{
Literal* literal = std::get_if<Literal>(&memoryGuardCall->arguments.front());
yulAssert(literal && literal->kind == LiteralKind::Number, "");
2020-09-17 15:25:37 +00:00
literal->value = YulString{util::toCompactHexWithPrefix(reservedMemory)};
2020-07-02 10:48:20 +00:00
}
}