cerc-io/solidity
10
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

modify unused store

Browse Source
This commit is contained in:
chriseth 2022-11-23 15:28:11 +01:00
parent 73fcf69188
commit bd7676873e
7 changed files with 452 additions and 467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
libyul/optimiser/UnusedAssignEliminator.cpp
View File

@ -25,27 +25,40 @@
#include <libyul/optimiser/Semantics.h> #include <libyul/optimiser/Semantics.h>
#include <libyul/optimiser/OptimizerUtilities.h> #include <libyul/optimiser/OptimizerUtilities.h>
#include <libyul/AST.h> #include <libyul/AST.h>
#include <libyul/AsmPrinter.h>
#include <libsolutil/CommonData.h> #include <libsolutil/CommonData.h>
#include <range/v3/action/remove_if.hpp> #include <range/v3/action/remove_if.hpp>
#include <iostream>
using namespace std; using namespace std;
using namespace solidity; using namespace solidity;
using namespace solidity::yul; using namespace solidity::yul;
// TODO this component does not handle reverting function calls specially. Is that OK?
// We should set m_activeStores to empty set for a reverting function call, like wo do with `leave`.
void UnusedAssignEliminator::run(OptimiserStepContext& _context, Block& _ast) void UnusedAssignEliminator::run(OptimiserStepContext& _context, Block& _ast)
{ {
UnusedAssignEliminator rae{_context.dialect}; UnusedAssignEliminator rae{_context.dialect};
rae(_ast); rae(_ast);
StatementRemover remover{rae.m_pendingRemovals}; set<Statement const*> toRemove;
for (Statement const* unusedStore: rae.m_allStores - rae.m_usedStores)
if (SideEffectsCollector{_context.dialect, *std::get<Assignment>(*unusedStore).value}.movable())
toRemove.insert(unusedStore);
else
cerr << "not used because not movable" << endl;
StatementRemover remover{toRemove};
remover(_ast); remover(_ast);
} }
void UnusedAssignEliminator::operator()(Identifier const& _identifier) void UnusedAssignEliminator::operator()(Identifier const& _identifier)
{ {
changeUndecidedTo(_identifier.name, State::Used); markUsed(_identifier.name);
} }
void UnusedAssignEliminator::operator()(VariableDeclaration const& _variableDeclaration) void UnusedAssignEliminator::operator()(VariableDeclaration const& _variableDeclaration)
@ -59,10 +72,10 @@ void UnusedAssignEliminator::operator()(VariableDeclaration const& _variableDecl
void UnusedAssignEliminator::operator()(Assignment const& _assignment) void UnusedAssignEliminator::operator()(Assignment const& _assignment)
{ {
visit(*_assignment.value); visit(*_assignment.value);
for (auto const& var: _assignment.variableNames) // Do not visit the variables because they are Identifiers
changeUndecidedTo(var.name, State::Unused);
} }
void UnusedAssignEliminator::operator()(FunctionDefinition const& _functionDefinition) void UnusedAssignEliminator::operator()(FunctionDefinition const& _functionDefinition)
{ {
ScopedSaveAndRestore outerDeclaredVariables(m_declaredVariables, {}); ScopedSaveAndRestore outerDeclaredVariables(m_declaredVariables, {});
@ -77,7 +90,7 @@ void UnusedAssignEliminator::operator()(FunctionDefinition const& _functionDefin
void UnusedAssignEliminator::operator()(Leave const&) void UnusedAssignEliminator::operator()(Leave const&)
{ {
for (YulString name: m_returnVariables) for (YulString name: m_returnVariables)
changeUndecidedTo(name, State::Used); markUsed(name);
} }
void UnusedAssignEliminator::operator()(Block const& _block) void UnusedAssignEliminator::operator()(Block const& _block)
@ -86,8 +99,10 @@ void UnusedAssignEliminator::operator()(Block const& _block)
UnusedStoreBase::operator()(_block); UnusedStoreBase::operator()(_block);
for (auto const& var: m_declaredVariables) for (auto const& statement: _block.statements)
finalize(var, State::Unused); if (auto const* varDecl = get_if<VariableDeclaration>(&statement))
for (auto const& var: varDecl->variables)
m_activeStores.erase(var.name);
} }
void UnusedAssignEliminator::visit(Statement const& _statement) void UnusedAssignEliminator::visit(Statement const& _statement)
@ -95,63 +110,53 @@ void UnusedAssignEliminator::visit(Statement const& _statement)
UnusedStoreBase::visit(_statement); UnusedStoreBase::visit(_statement);
if (auto const* assignment = get_if<Assignment>(&_statement)) if (auto const* assignment = get_if<Assignment>(&_statement))
if (assignment->variableNames.size() == 1) {
// Default-construct it in "Undecided" state if it does not yet exist. // TODO is it OK to do this for multi-assignments? I guess so because it is enough if
m_stores[assignment->variableNames.front().name][&_statement]; // one of them is used.
m_allStores.insert(&_statement);
for (auto const& var: assignment->variableNames)
m_activeStores[var.name] = {&_statement};
}
// cerr << "After " << std::visit(AsmPrinter{}, _statement) << endl;
// for (auto&& [var, assigns]: m_activeStores)
// {
// cerr << " " << var.str() << ":" << endl;
// for (auto const& assign: assigns)
// cerr << " " << std::visit(AsmPrinter{}, *assign) << endl;
// }
} }
void UnusedAssignEliminator::shortcutNestedLoop(TrackedStores const& _zeroRuns) void UnusedAssignEliminator::shortcutNestedLoop(ActiveStores const& _zeroRuns)
{ {
// Shortcut to avoid horrible runtime: // Shortcut to avoid horrible runtime:
// Change all assignments that were newly introduced in the for loop to "used". // Change all assignments that were newly introduced in the for loop to "used".
// We do not have to do that with the "break" or "continue" paths, because // We do not have to do that with the "break" or "continue" paths, because
// they will be joined later anyway. // they will be joined later anyway.
// TODO parallel traversal might be more efficient here. // TODO parallel traversal might be more efficient here.
for (auto& [variable, stores]: m_stores)
// TODO is this correct?
for (auto& [variable, stores]: m_activeStores)
for (auto& assignment: stores) for (auto& assignment: stores)
{ {
auto zeroIt = _zeroRuns.find(variable); auto zeroIt = _zeroRuns.find(variable);
if (zeroIt != _zeroRuns.end() && zeroIt->second.count(assignment.first)) if (zeroIt != _zeroRuns.end() && zeroIt->second.count(assignment))
continue; continue;
assignment.second = State::Value::Used; m_usedStores.insert(assignment);
} }
} }
void UnusedAssignEliminator::finalizeFunctionDefinition(FunctionDefinition const& _functionDefinition) void UnusedAssignEliminator::finalizeFunctionDefinition(FunctionDefinition const& _functionDefinition)
{ {
for (auto const& param: _functionDefinition.parameters)
finalize(param.name, State::Unused);
for (auto const& retParam: _functionDefinition.returnVariables) for (auto const& retParam: _functionDefinition.returnVariables)
finalize(retParam.name, State::Used); markUsed(retParam.name);
} }
void UnusedAssignEliminator::changeUndecidedTo(YulString _variable, UnusedAssignEliminator::State _newState) void UnusedAssignEliminator::markUsed(YulString _variable)
{ {
for (auto& assignment: m_stores[_variable]) for (auto& assignment: m_activeStores[_variable])
if (assignment.second == State::Undecided) m_usedStores.insert(assignment);
assignment.second = _newState; // TODO is this correct?
} m_activeStores.erase(_variable);
void UnusedAssignEliminator::finalize(YulString _variable, UnusedAssignEliminator::State _finalState)
{
std::map<Statement const*, State> stores = std::move(m_stores[_variable]);
m_stores.erase(_variable);
for (auto& breakAssignments: m_forLoopInfo.pendingBreakStmts)
{
util::joinMap(stores, std::move(breakAssignments[_variable]), State::join);
breakAssignments.erase(_variable);
}
for (auto& continueAssignments: m_forLoopInfo.pendingContinueStmts)
{
util::joinMap(stores, std::move(continueAssignments[_variable]), State::join);
continueAssignments.erase(_variable);
}
for (auto&& [statement, state]: stores)
if (
(state == State::Unused || (state == State::Undecided && _finalState == State::Unused)) &&
SideEffectsCollector{m_dialect, *std::get<Assignment>(*statement).value}.movable()
)
m_pendingRemovals.insert(statement);
} }

9
libyul/optimiser/UnusedAssignEliminator.h
View File

@ -126,15 +126,10 @@ public:
void visit(Statement const& _statement) override; void visit(Statement const& _statement) override;
private: private:
void shortcutNestedLoop(TrackedStores const& _beforeLoop) override; void shortcutNestedLoop(ActiveStores const& _beforeLoop) override;
void finalizeFunctionDefinition(FunctionDefinition const& _functionDefinition) override; void finalizeFunctionDefinition(FunctionDefinition const& _functionDefinition) override;
void changeUndecidedTo(YulString _variable, State _newState); void markUsed(YulString _variable);
/// Called when a variable goes out of scope. Sets the state of all still undecided
/// assignments to the final state. In this case, this also applies to pending
/// break and continue TrackedStores.
void finalize(YulString _variable, State _finalState);
std::set<YulString> m_declaredVariables; std::set<YulString> m_declaredVariables;
std::set<YulString> m_returnVariables; std::set<YulString> m_returnVariables;

52
libyul/optimiser/UnusedStoreBase.cpp
View File

@ -37,41 +37,41 @@ void UnusedStoreBase::operator()(If const& _if)
{ {
visit(*_if.condition); visit(*_if.condition);
TrackedStores skipBranch{m_stores}; ActiveStores skipBranch{m_activeStores};
(*this)(_if.body); (*this)(_if.body);
merge(m_stores, std::move(skipBranch)); merge(m_activeStores, std::move(skipBranch));
} }
void UnusedStoreBase::operator()(Switch const& _switch) void UnusedStoreBase::operator()(Switch const& _switch)
{ {
visit(*_switch.expression); visit(*_switch.expression);
TrackedStores const preState{m_stores}; ActiveStores const preState{m_activeStores};
bool hasDefault = false; bool hasDefault = false;
vector<TrackedStores> branches; vector<ActiveStores> branches;
for (auto const& c: _switch.cases) for (auto const& c: _switch.cases)
{ {
if (!c.value) if (!c.value)
hasDefault = true; hasDefault = true;
(*this)(c.body); (*this)(c.body);
branches.emplace_back(std::move(m_stores)); branches.emplace_back(std::move(m_activeStores));
m_stores = preState; m_activeStores = preState;
} }
if (hasDefault) if (hasDefault)
{ {
m_stores = std::move(branches.back()); m_activeStores = std::move(branches.back());
branches.pop_back(); branches.pop_back();
} }
for (auto& branch: branches) for (auto& branch: branches)
merge(m_stores, std::move(branch)); merge(m_activeStores, std::move(branch));
} }
void UnusedStoreBase::operator()(FunctionDefinition const& _functionDefinition) void UnusedStoreBase::operator()(FunctionDefinition const& _functionDefinition)
{ {
ScopedSaveAndRestore outerAssignments(m_stores, {}); ScopedSaveAndRestore outerAssignments(m_activeStores, {});
ScopedSaveAndRestore forLoopInfo(m_forLoopInfo, {}); ScopedSaveAndRestore forLoopInfo(m_forLoopInfo, {});
ScopedSaveAndRestore forLoopNestingDepth(m_forLoopNestingDepth, 0); ScopedSaveAndRestore forLoopNestingDepth(m_forLoopNestingDepth, 0);
@ -94,10 +94,10 @@ void UnusedStoreBase::operator()(ForLoop const& _forLoop)
visit(*_forLoop.condition); visit(*_forLoop.condition);
TrackedStores zeroRuns{m_stores}; ActiveStores zeroRuns{m_activeStores};
(*this)(_forLoop.body); (*this)(_forLoop.body);
merge(m_stores, std::move(m_forLoopInfo.pendingContinueStmts)); merge(m_activeStores, std::move(m_forLoopInfo.pendingContinueStmts));
m_forLoopInfo.pendingContinueStmts = {}; m_forLoopInfo.pendingContinueStmts = {};
(*this)(_forLoop.post); (*this)(_forLoop.post);
@ -106,54 +106,54 @@ void UnusedStoreBase::operator()(ForLoop const& _forLoop)
if (m_forLoopNestingDepth < 6) if (m_forLoopNestingDepth < 6)
{ {
// Do the second run only for small nesting depths to avoid horrible runtime. // Do the second run only for small nesting depths to avoid horrible runtime.
TrackedStores oneRun{m_stores}; ActiveStores oneRun{m_activeStores};
(*this)(_forLoop.body); (*this)(_forLoop.body);
merge(m_stores, std::move(m_forLoopInfo.pendingContinueStmts)); merge(m_activeStores, std::move(m_forLoopInfo.pendingContinueStmts));
m_forLoopInfo.pendingContinueStmts.clear(); m_forLoopInfo.pendingContinueStmts.clear();
(*this)(_forLoop.post); (*this)(_forLoop.post);
visit(*_forLoop.condition); visit(*_forLoop.condition);
// Order of merging does not matter because "max" is commutative and associative. // Order of merging does not matter because "max" is commutative and associative.
merge(m_stores, std::move(oneRun)); merge(m_activeStores, std::move(oneRun));
} }
else else
// Shortcut to avoid horrible runtime. // Shortcut to avoid horrible runtime.
shortcutNestedLoop(zeroRuns); shortcutNestedLoop(zeroRuns);
// Order of merging does not matter because "max" is commutative and associative. // Order of merging does not matter because "max" is commutative and associative.
merge(m_stores, std::move(zeroRuns)); merge(m_activeStores, std::move(zeroRuns));
merge(m_stores, std::move(m_forLoopInfo.pendingBreakStmts)); merge(m_activeStores, std::move(m_forLoopInfo.pendingBreakStmts));
m_forLoopInfo.pendingBreakStmts.clear(); m_forLoopInfo.pendingBreakStmts.clear();
} }
void UnusedStoreBase::operator()(Break const&) void UnusedStoreBase::operator()(Break const&)
{ {
m_forLoopInfo.pendingBreakStmts.emplace_back(std::move(m_stores)); m_forLoopInfo.pendingBreakStmts.emplace_back(std::move(m_activeStores));
m_stores.clear(); m_activeStores.clear();
} }
void UnusedStoreBase::operator()(Continue const&) void UnusedStoreBase::operator()(Continue const&)
{ {
m_forLoopInfo.pendingContinueStmts.emplace_back(std::move(m_stores)); m_forLoopInfo.pendingContinueStmts.emplace_back(std::move(m_activeStores));
m_stores.clear(); m_activeStores.clear();
} }
void UnusedStoreBase::merge(TrackedStores& _target, TrackedStores&& _other) void UnusedStoreBase::merge(ActiveStores& _target, ActiveStores&& _other)
{ {
util::joinMap(_target, std::move(_other), []( util::joinMap(_target, std::move(_other), [](
map<Statement const*, State>& _assignmentHere, set<Statement const*>& _storesHere,
map<Statement const*, State>&& _assignmentThere set<Statement const*>&& _storesThere
) )
{ {
return util::joinMap(_assignmentHere, std::move(_assignmentThere), State::join); _storesHere += _storesThere;
}); });
} }
void UnusedStoreBase::merge(TrackedStores& _target, vector<TrackedStores>&& _source) void UnusedStoreBase::merge(ActiveStores& _target, vector<ActiveStores>&& _source)
{ {
for (TrackedStores& ts: _source) for (ActiveStores& ts: _source)
merge(_target, std::move(ts)); merge(_target, std::move(ts));
_source.clear(); _source.clear();
} }

36
libyul/optimiser/UnusedStoreBase.h
View File

@ -57,28 +57,12 @@ public:
void operator()(Continue const&) override; void operator()(Continue const&) override;
protected: protected:
class State using ActiveStores = std::map<YulString, std::set<Statement const*>>;
{
public:
enum Value { Unused, Undecided, Used };
State(Value _value = Undecided): m_value(_value) {}
inline bool operator==(State _other) const { return m_value == _other.m_value; }
inline bool operator!=(State _other) const { return !operator==(_other); }
static inline void join(State& _a, State const& _b)
{
// Using "max" works here because of the order of the values in the enum.
_a.m_value = Value(std::max(int(_a.m_value), int(_b.m_value)));
}
private:
Value m_value = Undecided;
};
using TrackedStores = std::map<YulString, std::map<Statement const*, State>>;
/// This function is called for a loop that is nested too deep to avoid /// This function is called for a loop that is nested too deep to avoid
/// horrible runtime and should just resolve the situation in a pragmatic /// horrible runtime and should just resolve the situation in a pragmatic
/// and correct manner. /// and correct manner.
virtual void shortcutNestedLoop(TrackedStores const& _beforeLoop) = 0; virtual void shortcutNestedLoop(ActiveStores const& _beforeLoop) = 0;
/// This function is called right before the scoped restore of the function definition. /// This function is called right before the scoped restore of the function definition.
virtual void finalizeFunctionDefinition(FunctionDefinition const& /*_functionDefinition*/) {} virtual void finalizeFunctionDefinition(FunctionDefinition const& /*_functionDefinition*/) {}
@ -86,20 +70,24 @@ protected:
/// Joins the assignment mapping of @a _source into @a _target according to the rules laid out /// Joins the assignment mapping of @a _source into @a _target according to the rules laid out
/// above. /// above.
/// Will destroy @a _source. /// Will destroy @a _source.
static void merge(TrackedStores& _target, TrackedStores&& _source); static void merge(ActiveStores& _target, ActiveStores&& _source);
static void merge(TrackedStores& _target, std::vector<TrackedStores>&& _source); static void merge(ActiveStores& _target, std::vector<ActiveStores>&& _source);
Dialect const& m_dialect; Dialect const& m_dialect;
std::set<Statement const*> m_pendingRemovals; /// Set of all stores encountered during the traversal
TrackedStores m_stores; std::set<Statement const*> m_allStores;
/// Set of stores that are marked as being used.
std::set<Statement const*> m_usedStores;
/// Active (undecided) stores in the current branch.
ActiveStores m_activeStores;
/// Working data for traversing for-loops. /// Working data for traversing for-loops.
struct ForLoopInfo struct ForLoopInfo
{ {
/// Tracked assignment states for each break statement. /// Tracked assignment states for each break statement.
std::vector<TrackedStores> pendingBreakStmts; std::vector<ActiveStores> pendingBreakStmts;
/// Tracked assignment states for each continue statement. /// Tracked assignment states for each continue statement.
std::vector<TrackedStores> pendingContinueStmts; std::vector<ActiveStores> pendingContinueStmts;
}; };
ForLoopInfo m_forLoopInfo; ForLoopInfo m_forLoopInfo;
size_t m_forLoopNestingDepth = 0; size_t m_forLoopNestingDepth = 0;

638
libyul/optimiser/UnusedStoreEliminator.cpp
View File

@ -50,359 +50,359 @@ static string const one{"@ 1"};
static string const thirtyTwo{"@ 32"}; static string const thirtyTwo{"@ 32"};
void UnusedStoreEliminator::run(OptimiserStepContext& _context, Block& _ast) void UnusedStoreEliminator::run(OptimiserStepContext& /*_context*/, Block& /*_ast*/)
{ {
map<YulString, SideEffects> functionSideEffects = SideEffectsPropagator::sideEffects( // map<YulString, SideEffects> functionSideEffects = SideEffectsPropagator::sideEffects(
_context.dialect, // _context.dialect,
CallGraphGenerator::callGraph(_ast) // CallGraphGenerator::callGraph(_ast)
); // );
SSAValueTracker ssaValues; // SSAValueTracker ssaValues;
ssaValues(_ast); // ssaValues(_ast);
map<YulString, AssignedValue> values; // map<YulString, AssignedValue> values;
for (auto const& [name, expression]: ssaValues.values()) // for (auto const& [name, expression]: ssaValues.values())
values[name] = AssignedValue{expression, {}}; // values[name] = AssignedValue{expression, {}};
Expression const zeroLiteral{Literal{{}, LiteralKind::Number, YulString{"0"}, {}}}; // Expression const zeroLiteral{Literal{{}, LiteralKind::Number, YulString{"0"}, {}}};
Expression const oneLiteral{Literal{{}, LiteralKind::Number, YulString{"1"}, {}}}; // Expression const oneLiteral{Literal{{}, LiteralKind::Number, YulString{"1"}, {}}};
Expression const thirtyTwoLiteral{Literal{{}, LiteralKind::Number, YulString{"32"}, {}}}; // Expression const thirtyTwoLiteral{Literal{{}, LiteralKind::Number, YulString{"32"}, {}}};
values[YulString{zero}] = AssignedValue{&zeroLiteral, {}}; // values[YulString{zero}] = AssignedValue{&zeroLiteral, {}};
values[YulString{one}] = AssignedValue{&oneLiteral, {}}; // values[YulString{one}] = AssignedValue{&oneLiteral, {}};
values[YulString{thirtyTwo}] = AssignedValue{&thirtyTwoLiteral, {}}; // values[YulString{thirtyTwo}] = AssignedValue{&thirtyTwoLiteral, {}};
bool const ignoreMemory = MSizeFinder::containsMSize(_context.dialect, _ast); // bool const ignoreMemory = MSizeFinder::containsMSize(_context.dialect, _ast);
UnusedStoreEliminator rse{ // UnusedStoreEliminator rse{
_context.dialect, // _context.dialect,
functionSideEffects, // functionSideEffects,
ControlFlowSideEffectsCollector{_context.dialect, _ast}.functionSideEffectsNamed(), // ControlFlowSideEffectsCollector{_context.dialect, _ast}.functionSideEffectsNamed(),
values, // values,
ignoreMemory // ignoreMemory
}; // };
rse(_ast); // rse(_ast);
if ( // if (
auto evmDialect = dynamic_cast<EVMDialect const*>(&_context.dialect); // auto evmDialect = dynamic_cast<EVMDialect const*>(&_context.dialect);
evmDialect && evmDialect->providesObjectAccess() // evmDialect && evmDialect->providesObjectAccess()
) // )
rse.changeUndecidedTo(State::Unused, Location::Memory); // rse.changeUndecidedTo(State::Unused, Location::Memory);
else // else
rse.changeUndecidedTo(State::Used, Location::Memory); // rse.changeUndecidedTo(State::Used, Location::Memory);
rse.changeUndecidedTo(State::Used, Location::Storage); // rse.changeUndecidedTo(State::Used, Location::Storage);
rse.scheduleUnusedForDeletion(); // rse.scheduleUnusedForDeletion();
StatementRemover remover(rse.m_pendingRemovals); // StatementRemover remover(rse.m_pendingRemovals);
remover(_ast); // remover(_ast);
} }
void UnusedStoreEliminator::operator()(FunctionCall const& _functionCall) //void UnusedStoreEliminator::operator()(FunctionCall const& _functionCall)
{ //{
UnusedStoreBase::operator()(_functionCall); // UnusedStoreBase::operator()(_functionCall);
for (Operation const& op: operationsFromFunctionCall(_functionCall)) // for (Operation const& op: operationsFromFunctionCall(_functionCall))
applyOperation(op); // applyOperation(op);
ControlFlowSideEffects sideEffects; // ControlFlowSideEffects sideEffects;
if (auto builtin = m_dialect.builtin(_functionCall.functionName.name)) // if (auto builtin = m_dialect.builtin(_functionCall.functionName.name))
sideEffects = builtin->controlFlowSideEffects; // sideEffects = builtin->controlFlowSideEffects;
else // else
sideEffects = m_controlFlowSideEffects.at(_functionCall.functionName.name); // sideEffects = m_controlFlowSideEffects.at(_functionCall.functionName.name);
if (sideEffects.canTerminate) // if (sideEffects.canTerminate)
changeUndecidedTo(State::Used, Location::Storage); // changeUndecidedTo(State::Used, Location::Storage);
if (!sideEffects.canContinue) // if (!sideEffects.canContinue)
{ // {
changeUndecidedTo(State::Unused, Location::Memory); // changeUndecidedTo(State::Unused, Location::Memory);
if (!sideEffects.canTerminate) // if (!sideEffects.canTerminate)
changeUndecidedTo(State::Unused, Location::Storage); // changeUndecidedTo(State::Unused, Location::Storage);
} // }
} //}
void UnusedStoreEliminator::operator()(FunctionDefinition const& _functionDefinition) //void UnusedStoreEliminator::operator()(FunctionDefinition const& _functionDefinition)
{ //{
ScopedSaveAndRestore storeOperations(m_storeOperations, {}); // ScopedSaveAndRestore storeOperations(m_storeOperations, {});
UnusedStoreBase::operator()(_functionDefinition); // UnusedStoreBase::operator()(_functionDefinition);
} //}
void UnusedStoreEliminator::operator()(Leave const&) //void UnusedStoreEliminator::operator()(Leave const&)
{ //{
changeUndecidedTo(State::Used); // changeUndecidedTo(State::Used);
} //}
void UnusedStoreEliminator::visit(Statement const& _statement) //void UnusedStoreEliminator::visit(Statement const& _statement)
{ //{
using evmasm::Instruction; // using evmasm::Instruction;
UnusedStoreBase::visit(_statement); // UnusedStoreBase::visit(_statement);
auto const* exprStatement = get_if<ExpressionStatement>(&_statement); // auto const* exprStatement = get_if<ExpressionStatement>(&_statement);
if (!exprStatement) // if (!exprStatement)
return; // return;
FunctionCall const* funCall = get_if<FunctionCall>(&exprStatement->expression); // FunctionCall const* funCall = get_if<FunctionCall>(&exprStatement->expression);
yulAssert(funCall); // yulAssert(funCall);
optional<Instruction> instruction = toEVMInstruction(m_dialect, funCall->functionName.name); // optional<Instruction> instruction = toEVMInstruction(m_dialect, funCall->functionName.name);
if (!instruction) // if (!instruction)
return; // return;
if (!ranges::all_of(funCall->arguments, [](Expression const& _expr) -> bool { // if (!ranges::all_of(funCall->arguments, [](Expression const& _expr) -> bool {
return get_if<Identifier>(&_expr) || get_if<Literal>(&_expr); // return get_if<Identifier>(&_expr) || get_if<Literal>(&_expr);
})) // }))
return; // return;
// We determine if this is a store instruction without additional side-effects // // We determine if this is a store instruction without additional side-effects
// both by querying a combination of semantic information and by listing the instructions. // // both by querying a combination of semantic information and by listing the instructions.
// This way the assert below should be triggered on any change. // // This way the assert below should be triggered on any change.
using evmasm::SemanticInformation; // using evmasm::SemanticInformation;
bool isStorageWrite = (*instruction == Instruction::SSTORE); // bool isStorageWrite = (*instruction == Instruction::SSTORE);
bool isMemoryWrite = // bool isMemoryWrite =
*instruction == Instruction::EXTCODECOPY || // *instruction == Instruction::EXTCODECOPY ||
*instruction == Instruction::CODECOPY || // *instruction == Instruction::CODECOPY ||
*instruction == Instruction::CALLDATACOPY || // *instruction == Instruction::CALLDATACOPY ||
*instruction == Instruction::RETURNDATACOPY || // *instruction == Instruction::RETURNDATACOPY ||
*instruction == Instruction::MSTORE || // *instruction == Instruction::MSTORE ||
*instruction == Instruction::MSTORE8; // *instruction == Instruction::MSTORE8;
bool isCandidateForRemoval = // bool isCandidateForRemoval =
SemanticInformation::otherState(*instruction) != SemanticInformation::Write && ( // SemanticInformation::otherState(*instruction) != SemanticInformation::Write && (
SemanticInformation::storage(*instruction) == SemanticInformation::Write || // SemanticInformation::storage(*instruction) == SemanticInformation::Write ||
(!m_ignoreMemory && SemanticInformation::memory(*instruction) == SemanticInformation::Write) // (!m_ignoreMemory && SemanticInformation::memory(*instruction) == SemanticInformation::Write)
); // );
yulAssert(isCandidateForRemoval == (isStorageWrite || (!m_ignoreMemory && isMemoryWrite))); // yulAssert(isCandidateForRemoval == (isStorageWrite || (!m_ignoreMemory && isMemoryWrite)));
if (isCandidateForRemoval) // if (isCandidateForRemoval)
{ // {
State initialState = State::Undecided; // State initialState = State::Undecided;
if (*instruction == Instruction::RETURNDATACOPY) // if (*instruction == Instruction::RETURNDATACOPY)
{ // {
initialState = State::Used; // initialState = State::Used;
auto startOffset = identifierNameIfSSA(funCall->arguments.at(1)); // auto startOffset = identifierNameIfSSA(funCall->arguments.at(1));
auto length = identifierNameIfSSA(funCall->arguments.at(2)); // auto length = identifierNameIfSSA(funCall->arguments.at(2));
KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); }); // KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); });
if (length && startOffset) // if (length && startOffset)
{ // {
FunctionCall const* lengthCall = get_if<FunctionCall>(m_ssaValues.at(*length).value); // FunctionCall const* lengthCall = get_if<FunctionCall>(m_ssaValues.at(*length).value);
if ( // if (
knowledge.knownToBeZero(*startOffset) && // knowledge.knownToBeZero(*startOffset) &&
lengthCall && // lengthCall &&
toEVMInstruction(m_dialect, lengthCall->functionName.name) == Instruction::RETURNDATASIZE // toEVMInstruction(m_dialect, lengthCall->functionName.name) == Instruction::RETURNDATASIZE
) // )
initialState = State::Undecided; // initialState = State::Undecided;
} // }
} // }
m_stores[YulString{}].insert({&_statement, initialState}); // m_activeStores[YulString{}].insert({&_statement, initialState});
vector<Operation> operations = operationsFromFunctionCall(*funCall); // vector<Operation> operations = operationsFromFunctionCall(*funCall);
yulAssert(operations.size() == 1, ""); // yulAssert(operations.size() == 1, "");
m_storeOperations[&_statement] = std::move(operations.front()); // m_storeOperations[&_statement] = std::move(operations.front());
} // }
} //}
void UnusedStoreEliminator::finalizeFunctionDefinition(FunctionDefinition const&) //void UnusedStoreEliminator::finalizeFunctionDefinition(FunctionDefinition const&)
{ //{
changeUndecidedTo(State::Used); // changeUndecidedTo(State::Used);
scheduleUnusedForDeletion(); // scheduleUnusedForDeletion();
} //}
vector<UnusedStoreEliminator::Operation> UnusedStoreEliminator::operationsFromFunctionCall( //vector<UnusedStoreEliminator::Operation> UnusedStoreEliminator::operationsFromFunctionCall(
FunctionCall const& _functionCall // FunctionCall const& _functionCall
) const //) const
{ //{
using evmasm::Instruction; // using evmasm::Instruction;
YulString functionName = _functionCall.functionName.name; // YulString functionName = _functionCall.functionName.name;
SideEffects sideEffects; // SideEffects sideEffects;
if (BuiltinFunction const* f = m_dialect.builtin(functionName)) // if (BuiltinFunction const* f = m_dialect.builtin(functionName))
sideEffects = f->sideEffects; // sideEffects = f->sideEffects;
else // else
sideEffects = m_functionSideEffects.at(functionName); // sideEffects = m_functionSideEffects.at(functionName);
optional<Instruction> instruction = toEVMInstruction(m_dialect, functionName); // optional<Instruction> instruction = toEVMInstruction(m_dialect, functionName);
if (!instruction) // if (!instruction)
{ // {
vector<Operation> result; // vector<Operation> result;
// Unknown read is worse than unknown write. // // Unknown read is worse than unknown write.
if (sideEffects.memory != SideEffects::Effect::None) // if (sideEffects.memory != SideEffects::Effect::None)
result.emplace_back(Operation{Location::Memory, Effect::Read, {}, {}}); // result.emplace_back(Operation{Location::Memory, Effect::Read, {}, {}});
if (sideEffects.storage != SideEffects::Effect::None) // if (sideEffects.storage != SideEffects::Effect::None)
result.emplace_back(Operation{Location::Storage, Effect::Read, {}, {}}); // result.emplace_back(Operation{Location::Storage, Effect::Read, {}, {}});
return result; // return result;
} // }
using evmasm::SemanticInformation; // using evmasm::SemanticInformation;
return util::applyMap( // return util::applyMap(
SemanticInformation::readWriteOperations(*instruction), // SemanticInformation::readWriteOperations(*instruction),
[&](SemanticInformation::Operation const& _op) -> Operation // [&](SemanticInformation::Operation const& _op) -> Operation
{ // {
yulAssert(!(_op.lengthParameter && _op.lengthConstant)); // yulAssert(!(_op.lengthParameter && _op.lengthConstant));
yulAssert(_op.effect != Effect::None); // yulAssert(_op.effect != Effect::None);
Operation ourOp{_op.location, _op.effect, {}, {}}; // Operation ourOp{_op.location, _op.effect, {}, {}};
if (_op.startParameter) // if (_op.startParameter)
ourOp.start = identifierNameIfSSA(_functionCall.arguments.at(*_op.startParameter)); // ourOp.start = identifierNameIfSSA(_functionCall.arguments.at(*_op.startParameter));
if (_op.lengthParameter) // if (_op.lengthParameter)
ourOp.length = identifierNameIfSSA(_functionCall.arguments.at(*_op.lengthParameter)); // ourOp.length = identifierNameIfSSA(_functionCall.arguments.at(*_op.lengthParameter));
if (_op.lengthConstant) // if (_op.lengthConstant)
switch (*_op.lengthConstant) // switch (*_op.lengthConstant)
{ // {
case 1: ourOp.length = YulString(one); break; // case 1: ourOp.length = YulString(one); break;
case 32: ourOp.length = YulString(thirtyTwo); break; // case 32: ourOp.length = YulString(thirtyTwo); break;
default: yulAssert(false); // default: yulAssert(false);
} // }
return ourOp; // return ourOp;
} // }
); // );
} //}
void UnusedStoreEliminator::applyOperation(UnusedStoreEliminator::Operation const& _operation) //void UnusedStoreEliminator::applyOperation(UnusedStoreEliminator::Operation const& _operation)
{ //{
for (auto& [statement, state]: m_stores[YulString{}]) // for (auto& [statement, state]: m_activeStores[YulString{}])
if (state == State::Undecided) // if (state == State::Undecided)
{ // {
Operation const& storeOperation = m_storeOperations.at(statement); // Operation const& storeOperation = m_storeOperations.at(statement);
if (_operation.effect == Effect::Read && !knownUnrelated(storeOperation, _operation)) // if (_operation.effect == Effect::Read && !knownUnrelated(storeOperation, _operation))
state = State::Used; // state = State::Used;
else if (_operation.effect == Effect::Write && knownCovered(storeOperation, _operation)) // else if (_operation.effect == Effect::Write && knownCovered(storeOperation, _operation))
state = State::Unused; // state = State::Unused;
} // }
} //}
bool UnusedStoreEliminator::knownUnrelated( //bool UnusedStoreEliminator::knownUnrelated(
UnusedStoreEliminator::Operation const& _op1, // UnusedStoreEliminator::Operation const& _op1,
UnusedStoreEliminator::Operation const& _op2 // UnusedStoreEliminator::Operation const& _op2
) const //) const
{ //{
KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); }); // KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); });
if (_op1.location != _op2.location) // if (_op1.location != _op2.location)
return true; // return true;
if (_op1.location == Location::Storage) // if (_op1.location == Location::Storage)
{ // {
if (_op1.start && _op2.start) // if (_op1.start && _op2.start)
{ // {
yulAssert( // yulAssert(
_op1.length && // _op1.length &&
_op2.length && // _op2.length &&
knowledge.valueIfKnownConstant(*_op1.length) == 1 && // knowledge.valueIfKnownConstant(*_op1.length) == 1 &&
knowledge.valueIfKnownConstant(*_op2.length) == 1 // knowledge.valueIfKnownConstant(*_op2.length) == 1
); // );
return knowledge.knownToBeDifferent(*_op1.start, *_op2.start); // return knowledge.knownToBeDifferent(*_op1.start, *_op2.start);
} // }
} // }
else // else
{ // {
yulAssert(_op1.location == Location::Memory, ""); // yulAssert(_op1.location == Location::Memory, "");
if ( // if (
(_op1.length && knowledge.knownToBeZero(*_op1.length)) || // (_op1.length && knowledge.knownToBeZero(*_op1.length)) ||
(_op2.length && knowledge.knownToBeZero(*_op2.length)) // (_op2.length && knowledge.knownToBeZero(*_op2.length))
) // )
return true; // return true;
if (_op1.start && _op1.length && _op2.start) // if (_op1.start && _op1.length && _op2.start)
{ // {
optional<u256> length1 = knowledge.valueIfKnownConstant(*_op1.length); // optional<u256> length1 = knowledge.valueIfKnownConstant(*_op1.length);
optional<u256> start1 = knowledge.valueIfKnownConstant(*_op1.start); // optional<u256> start1 = knowledge.valueIfKnownConstant(*_op1.start);
optional<u256> start2 = knowledge.valueIfKnownConstant(*_op2.start); // optional<u256> start2 = knowledge.valueIfKnownConstant(*_op2.start);
if ( // if (
(length1 && start1 && start2) && // (length1 && start1 && start2) &&
*start1 + *length1 >= *start1 && // no overflow // *start1 + *length1 >= *start1 && // no overflow
*start1 + *length1 <= *start2 // *start1 + *length1 <= *start2
) // )
return true; // return true;
} // }
if (_op2.start && _op2.length && _op1.start) // if (_op2.start && _op2.length && _op1.start)
{ // {
optional<u256> length2 = knowledge.valueIfKnownConstant(*_op2.length); // optional<u256> length2 = knowledge.valueIfKnownConstant(*_op2.length);
optional<u256> start2 = knowledge.valueIfKnownConstant(*_op2.start); // optional<u256> start2 = knowledge.valueIfKnownConstant(*_op2.start);
optional<u256> start1 = knowledge.valueIfKnownConstant(*_op1.start); // optional<u256> start1 = knowledge.valueIfKnownConstant(*_op1.start);
if ( // if (
(length2 && start2 && start1) && // (length2 && start2 && start1) &&
*start2 + *length2 >= *start2 && // no overflow // *start2 + *length2 >= *start2 && // no overflow
*start2 + *length2 <= *start1 // *start2 + *length2 <= *start1
) // )
return true; // return true;
} // }
if (_op1.start && _op1.length && _op2.start && _op2.length) // if (_op1.start && _op1.length && _op2.start && _op2.length)
{ // {
optional<u256> length1 = knowledge.valueIfKnownConstant(*_op1.length); // optional<u256> length1 = knowledge.valueIfKnownConstant(*_op1.length);
optional<u256> length2 = knowledge.valueIfKnownConstant(*_op2.length); // optional<u256> length2 = knowledge.valueIfKnownConstant(*_op2.length);
if ( // if (
(length1 && *length1 <= 32) && // (length1 && *length1 <= 32) &&
(length2 && *length2 <= 32) && // (length2 && *length2 <= 32) &&
knowledge.knownToBeDifferentByAtLeast32(*_op1.start, *_op2.start) // knowledge.knownToBeDifferentByAtLeast32(*_op1.start, *_op2.start)
) // )
return true; // return true;
} // }
} // }
return false; // return false;
} //}
bool UnusedStoreEliminator::knownCovered( //bool UnusedStoreEliminator::knownCovered(
UnusedStoreEliminator::Operation const& _covered, // UnusedStoreEliminator::Operation const& _covered,
UnusedStoreEliminator::Operation const& _covering // UnusedStoreEliminator::Operation const& _covering
) const //) const
{ //{
if (_covered.location != _covering.location) // if (_covered.location != _covering.location)
return false; // return false;
if ( // if (
(_covered.start && _covered.start == _covering.start) && // (_covered.start && _covered.start == _covering.start) &&
(_covered.length && _covered.length == _covering.length) // (_covered.length && _covered.length == _covering.length)
) // )
return true; // return true;
if (_covered.location == Location::Memory) // if (_covered.location == Location::Memory)
{ // {
KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); }); // KnowledgeBase knowledge(m_dialect, [this](YulString _var) { return util::valueOrNullptr(m_ssaValues, _var); });
if (_covered.length && knowledge.knownToBeZero(*_covered.length)) // if (_covered.length && knowledge.knownToBeZero(*_covered.length))
return true; // return true;
// Condition (i = cover_i_ng, e = cover_e_d): // // Condition (i = cover_i_ng, e = cover_e_d):
// i.start <= e.start && e.start + e.length <= i.start + i.length // // i.start <= e.start && e.start + e.length <= i.start + i.length
if (!_covered.start || !_covering.start || !_covered.length || !_covering.length) // if (!_covered.start || !_covering.start || !_covered.length || !_covering.length)
return false; // return false;
optional<u256> coveredLength = knowledge.valueIfKnownConstant(*_covered.length); // optional<u256> coveredLength = knowledge.valueIfKnownConstant(*_covered.length);
optional<u256> coveringLength = knowledge.valueIfKnownConstant(*_covering.length); // optional<u256> coveringLength = knowledge.valueIfKnownConstant(*_covering.length);
if (knowledge.knownToBeEqual(*_covered.start, *_covering.start)) // if (knowledge.knownToBeEqual(*_covered.start, *_covering.start))
if (coveredLength && coveringLength && *coveredLength <= *coveringLength) // if (coveredLength && coveringLength && *coveredLength <= *coveringLength)
return true; // return true;
optional<u256> coveredStart = knowledge.valueIfKnownConstant(*_covered.start); // optional<u256> coveredStart = knowledge.valueIfKnownConstant(*_covered.start);
optional<u256> coveringStart = knowledge.valueIfKnownConstant(*_covering.start); // optional<u256> coveringStart = knowledge.valueIfKnownConstant(*_covering.start);
if (coveredStart && coveringStart && coveredLength && coveringLength) // if (coveredStart && coveringStart && coveredLength && coveringLength)
if ( // if (
*coveringStart <= *coveredStart && // *coveringStart <= *coveredStart &&
*coveringStart + *coveringLength >= *coveringStart && // no overflow // *coveringStart + *coveringLength >= *coveringStart && // no overflow
*coveredStart + *coveredLength >= *coveredStart && // no overflow // *coveredStart + *coveredLength >= *coveredStart && // no overflow
*coveredStart + *coveredLength <= *coveringStart + *coveringLength // *coveredStart + *coveredLength <= *coveringStart + *coveringLength
) // )
return true; // return true;
// TODO for this we probably need a non-overflow assumption as above. // // TODO for this we probably need a non-overflow assumption as above.
// Condition (i = cover_i_ng, e = cover_e_d): // // Condition (i = cover_i_ng, e = cover_e_d):
// i.start <= e.start && e.start + e.length <= i.start + i.length // // i.start <= e.start && e.start + e.length <= i.start + i.length
} // }
return false; // return false;
} //}
void UnusedStoreEliminator::changeUndecidedTo( //void UnusedStoreEliminator::changeUndecidedTo(
State _newState, // State _newState,
optional<UnusedStoreEliminator::Location> _onlyLocation) // optional<UnusedStoreEliminator::Location> _onlyLocation)
{ //{
for (auto& [statement, state]: m_stores[YulString{}]) // for (auto& [statement, state]: m_activeStores[YulString{}])
if ( // if (
state == State::Undecided && // state == State::Undecided &&
(_onlyLocation == nullopt || *_onlyLocation == m_storeOperations.at(statement).location) // (_onlyLocation == nullopt || *_onlyLocation == m_storeOperations.at(statement).location)
) // )
state = _newState; // state = _newState;
} //}
optional<YulString> UnusedStoreEliminator::identifierNameIfSSA(Expression const& _expression) const //optional<YulString> UnusedStoreEliminator::identifierNameIfSSA(Expression const& _expression) const
{ //{
if (Identifier const* identifier = get_if<Identifier>(&_expression)) // if (Identifier const* identifier = get_if<Identifier>(&_expression))
if (m_ssaValues.count(identifier->name)) // if (m_ssaValues.count(identifier->name))
return {identifier->name}; // return {identifier->name};
return nullopt; // return nullopt;
} //}
void UnusedStoreEliminator::scheduleUnusedForDeletion() //void UnusedStoreEliminator::scheduleUnusedForDeletion()
{ //{
for (auto const& [statement, state]: m_stores[YulString{}]) // for (auto const& [statement, state]: m_activeStores[YulString{}])
if (state == State::Unused) // if (state == State::Unused)
m_pendingRemovals.insert(statement); // m_pendingRemovals.insert(statement);
} //}

84
libyul/optimiser/UnusedStoreEliminator.h
View File

@ -64,63 +64,63 @@ public:
explicit UnusedStoreEliminator( explicit UnusedStoreEliminator(
Dialect const& _dialect, Dialect const& _dialect,
std::map<YulString, SideEffects> const& _functionSideEffects, std::map<YulString, SideEffects> const& ,//_functionSideEffects,
std::map<YulString, ControlFlowSideEffects> _controlFlowSideEffects, std::map<YulString, ControlFlowSideEffects>,// _controlFlowSideEffects,
std::map<YulString, AssignedValue> const& _ssaValues, std::map<YulString, AssignedValue> const&,// _ssaValues,
bool _ignoreMemory bool// _ignoreMemory
): ):
UnusedStoreBase(_dialect), UnusedStoreBase(_dialect)//,
m_ignoreMemory(_ignoreMemory), // m_ignoreMemory(_ignoreMemory),
m_functionSideEffects(_functionSideEffects), // m_functionSideEffects(_functionSideEffects),
m_controlFlowSideEffects(_controlFlowSideEffects), // m_controlFlowSideEffects(_controlFlowSideEffects),
m_ssaValues(_ssaValues) // m_ssaValues(_ssaValues)
{} {}
using UnusedStoreBase::operator(); // using UnusedStoreBase::operator();
void operator()(FunctionCall const& _functionCall) override; // void operator()(FunctionCall const& _functionCall) override;
void operator()(FunctionDefinition const&) override; // void operator()(FunctionDefinition const&) override;
void operator()(Leave const&) override; // void operator()(Leave const&) override;
using UnusedStoreBase::visit; // using UnusedStoreBase::visit;
void visit(Statement const& _statement) override; // void visit(Statement const& _statement) override;
using Location = evmasm::SemanticInformation::Location; // using Location = evmasm::SemanticInformation::Location;
using Effect = evmasm::SemanticInformation::Effect; // using Effect = evmasm::SemanticInformation::Effect;
struct Operation // struct Operation
{ // {
Location location; // Location location;
Effect effect; // Effect effect;
/// Start of affected area. Unknown if not provided. // /// Start of affected area. Unknown if not provided.
std::optional<YulString> start; // std::optional<YulString> start;
/// Length of affected area, unknown if not provided. // /// Length of affected area, unknown if not provided.
/// Unused for storage. // /// Unused for storage.
std::optional<YulString> length; // std::optional<YulString> length;
}; // };
private: private:
void shortcutNestedLoop(TrackedStores const&) override void shortcutNestedLoop(ActiveStores const&) override
{ {
// We might only need to do this for newly introduced stores in the loop. // We might only need to do this for newly introduced stores in the loop.
changeUndecidedTo(State::Used); // changeUndecidedTo(State::Used);
} }
void finalizeFunctionDefinition(FunctionDefinition const&) override; // void finalizeFunctionDefinition(FunctionDefinition const&) override;
std::vector<Operation> operationsFromFunctionCall(FunctionCall const& _functionCall) const; // std::vector<Operation> operationsFromFunctionCall(FunctionCall const& _functionCall) const;
void applyOperation(Operation const& _operation); // void applyOperation(Operation const& _operation);
bool knownUnrelated(Operation const& _op1, Operation const& _op2) const; // bool knownUnrelated(Operation const& _op1, Operation const& _op2) const;
bool knownCovered(Operation const& _covered, Operation const& _covering) const; // bool knownCovered(Operation const& _covered, Operation const& _covering) const;
void changeUndecidedTo(State _newState, std::optional<Location> _onlyLocation = std::nullopt); // void changeUndecidedTo(State _newState, std::optional<Location> _onlyLocation = std::nullopt);
void scheduleUnusedForDeletion(); // void scheduleUnusedForDeletion();
std::optional<YulString> identifierNameIfSSA(Expression const& _expression) const; // std::optional<YulString> identifierNameIfSSA(Expression const& _expression) const;
bool const m_ignoreMemory; // bool const m_ignoreMemory;
std::map<YulString, SideEffects> const& m_functionSideEffects; // std::map<YulString, SideEffects> const& m_functionSideEffects;
std::map<YulString, ControlFlowSideEffects> m_controlFlowSideEffects; // std::map<YulString, ControlFlowSideEffects> m_controlFlowSideEffects;
std::map<YulString, AssignedValue> const& m_ssaValues; // std::map<YulString, AssignedValue> const& m_ssaValues;
std::map<Statement const*, Operation> m_storeOperations; // std::map<Statement const*, Operation> m_storeOperations;
}; };
} }

5
test/libyul/yulOptimizerTests/unusedAssignEliminator/for_deep_noremove.yul
View File

@ -46,10 +46,7 @@
// for { } 1 { } // for { } 1 { }
// { // {
// for { } 1 { a := 10 } // for { } 1 { a := 10 }
// { // { b := 11 }
// b := 12
// b := 11
// }
// } // }
// } // }
// } // }