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

Merge pull request #9577 from ethereum/removeflag

Browse Source 
Remove "removesNonConstant" flag.
This commit is contained in:
chriseth 2020-09-14 20:20:46 +02:00 committed by GitHub
commit c6281f29d5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
46 changed files with 483 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
libevmasm/RuleList.h
View File

@ -73,49 +73,49 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart1(
using Builtins = typename Pattern::Builtins; using Builtins = typename Pattern::Builtins;
return std::vector<SimplificationRule<Pattern>>{ return std::vector<SimplificationRule<Pattern>>{
// arithmetic on constants // arithmetic on constants
{Builtins::ADD(A, B), [=]{ return A.d() + B.d(); }, false}, {Builtins::ADD(A, B), [=]{ return A.d() + B.d(); }},
{Builtins::MUL(A, B), [=]{ return A.d() * B.d(); }, false}, {Builtins::MUL(A, B), [=]{ return A.d() * B.d(); }},
{Builtins::SUB(A, B), [=]{ return A.d() - B.d(); }, false}, {Builtins::SUB(A, B), [=]{ return A.d() - B.d(); }},
{Builtins::DIV(A, B), [=]{ return B.d() == 0 ? 0 : divWorkaround(A.d(), B.d()); }, false}, {Builtins::DIV(A, B), [=]{ return B.d() == 0 ? 0 : divWorkaround(A.d(), B.d()); }},
{Builtins::SDIV(A, B), [=]{ return B.d() == 0 ? 0 : s2u(divWorkaround(u2s(A.d()), u2s(B.d()))); }, false}, {Builtins::SDIV(A, B), [=]{ return B.d() == 0 ? 0 : s2u(divWorkaround(u2s(A.d()), u2s(B.d()))); }},
{Builtins::MOD(A, B), [=]{ return B.d() == 0 ? 0 : modWorkaround(A.d(), B.d()); }, false}, {Builtins::MOD(A, B), [=]{ return B.d() == 0 ? 0 : modWorkaround(A.d(), B.d()); }},
{Builtins::SMOD(A, B), [=]{ return B.d() == 0 ? 0 : s2u(modWorkaround(u2s(A.d()), u2s(B.d()))); }, false}, {Builtins::SMOD(A, B), [=]{ return B.d() == 0 ? 0 : s2u(modWorkaround(u2s(A.d()), u2s(B.d()))); }},
{Builtins::EXP(A, B), [=]{ return Word(boost::multiprecision::powm(bigint(A.d()), bigint(B.d()), bigint(1) << Pattern::WordSize)); }, false}, {Builtins::EXP(A, B), [=]{ return Word(boost::multiprecision::powm(bigint(A.d()), bigint(B.d()), bigint(1) << Pattern::WordSize)); }},
{Builtins::NOT(A), [=]{ return ~A.d(); }, false}, {Builtins::NOT(A), [=]{ return ~A.d(); }},
{Builtins::LT(A, B), [=]() -> Word { return A.d() < B.d() ? 1 : 0; }, false}, {Builtins::LT(A, B), [=]() -> Word { return A.d() < B.d() ? 1 : 0; }},
{Builtins::GT(A, B), [=]() -> Word { return A.d() > B.d() ? 1 : 0; }, false}, {Builtins::GT(A, B), [=]() -> Word { return A.d() > B.d() ? 1 : 0; }},
{Builtins::SLT(A, B), [=]() -> Word { return u2s(A.d()) < u2s(B.d()) ? 1 : 0; }, false}, {Builtins::SLT(A, B), [=]() -> Word { return u2s(A.d()) < u2s(B.d()) ? 1 : 0; }},
{Builtins::SGT(A, B), [=]() -> Word { return u2s(A.d()) > u2s(B.d()) ? 1 : 0; }, false}, {Builtins::SGT(A, B), [=]() -> Word { return u2s(A.d()) > u2s(B.d()) ? 1 : 0; }},
{Builtins::EQ(A, B), [=]() -> Word { return A.d() == B.d() ? 1 : 0; }, false}, {Builtins::EQ(A, B), [=]() -> Word { return A.d() == B.d() ? 1 : 0; }},
{Builtins::ISZERO(A), [=]() -> Word { return A.d() == 0 ? 1 : 0; }, false}, {Builtins::ISZERO(A), [=]() -> Word { return A.d() == 0 ? 1 : 0; }},
{Builtins::AND(A, B), [=]{ return A.d() & B.d(); }, false}, {Builtins::AND(A, B), [=]{ return A.d() & B.d(); }},
{Builtins::OR(A, B), [=]{ return A.d() | B.d(); }, false}, {Builtins::OR(A, B), [=]{ return A.d() | B.d(); }},
{Builtins::XOR(A, B), [=]{ return A.d() ^ B.d(); }, false}, {Builtins::XOR(A, B), [=]{ return A.d() ^ B.d(); }},
{Builtins::BYTE(A, B), [=]{ {Builtins::BYTE(A, B), [=]{
return return
A.d() >= Pattern::WordSize / 8 ? A.d() >= Pattern::WordSize / 8 ?
0 : 0 :
(B.d() >> unsigned(8 * (Pattern::WordSize / 8 - 1 - A.d()))) & 0xff; (B.d() >> unsigned(8 * (Pattern::WordSize / 8 - 1 - A.d()))) & 0xff;
}, false}, }},
{Builtins::ADDMOD(A, B, C), [=]{ return C.d() == 0 ? 0 : Word((bigint(A.d()) + bigint(B.d())) % C.d()); }, false}, {Builtins::ADDMOD(A, B, C), [=]{ return C.d() == 0 ? 0 : Word((bigint(A.d()) + bigint(B.d())) % C.d()); }},
{Builtins::MULMOD(A, B, C), [=]{ return C.d() == 0 ? 0 : Word((bigint(A.d()) * bigint(B.d())) % C.d()); }, false}, {Builtins::MULMOD(A, B, C), [=]{ return C.d() == 0 ? 0 : Word((bigint(A.d()) * bigint(B.d())) % C.d()); }},
{Builtins::SIGNEXTEND(A, B), [=]() -> Word { {Builtins::SIGNEXTEND(A, B), [=]() -> Word {
if (A.d() >= Pattern::WordSize / 8 - 1) if (A.d() >= Pattern::WordSize / 8 - 1)
return B.d(); return B.d();
unsigned testBit = unsigned(A.d()) * 8 + 7; unsigned testBit = unsigned(A.d()) * 8 + 7;
Word mask = (Word(1) << testBit) - 1; Word mask = (Word(1) << testBit) - 1;
return boost::multiprecision::bit_test(B.d(), testBit) ? B.d() | ~mask : B.d() & mask; return boost::multiprecision::bit_test(B.d(), testBit) ? B.d() | ~mask : B.d() & mask;
}, false}, }},
{Builtins::SHL(A, B), [=]{ {Builtins::SHL(A, B), [=]{
if (A.d() >= Pattern::WordSize) if (A.d() >= Pattern::WordSize)
return Word(0); return Word(0);
return shlWorkaround(B.d(), unsigned(A.d())); return shlWorkaround(B.d(), unsigned(A.d()));
}, false}, }},
{Builtins::SHR(A, B), [=]{ {Builtins::SHR(A, B), [=]{
if (A.d() >= Pattern::WordSize) if (A.d() >= Pattern::WordSize)
return Word(0); return Word(0);
return B.d() >> unsigned(A.d()); return B.d() >> unsigned(A.d());
}, false} }}
}; };
} }
@ -133,48 +133,48 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart2(
using Builtins = typename Pattern::Builtins; using Builtins = typename Pattern::Builtins;
return std::vector<SimplificationRule<Pattern>> { return std::vector<SimplificationRule<Pattern>> {
// invariants involving known constants // invariants involving known constants
{Builtins::ADD(X, 0), [=]{ return X; }, false}, {Builtins::ADD(X, 0), [=]{ return X; }},
{Builtins::ADD(0, X), [=]{ return X; }, false}, {Builtins::ADD(0, X), [=]{ return X; }},
{Builtins::SUB(X, 0), [=]{ return X; }, false}, {Builtins::SUB(X, 0), [=]{ return X; }},
{Builtins::SUB(~Word(0), X), [=]() -> Pattern { return Builtins::NOT(X); }, false}, {Builtins::SUB(~Word(0), X), [=]() -> Pattern { return Builtins::NOT(X); }},
{Builtins::MUL(X, 0), [=]{ return Word(0); }, true}, {Builtins::MUL(X, 0), [=]{ return Word(0); }},
{Builtins::MUL(0, X), [=]{ return Word(0); }, true}, {Builtins::MUL(0, X), [=]{ return Word(0); }},
{Builtins::MUL(X, 1), [=]{ return X; }, false}, {Builtins::MUL(X, 1), [=]{ return X; }},
{Builtins::MUL(1, X), [=]{ return X; }, false}, {Builtins::MUL(1, X), [=]{ return X; }},
{Builtins::MUL(X, Word(-1)), [=]() -> Pattern { return Builtins::SUB(0, X); }, false}, {Builtins::MUL(X, Word(-1)), [=]() -> Pattern { return Builtins::SUB(0, X); }},
{Builtins::MUL(Word(-1), X), [=]() -> Pattern { return Builtins::SUB(0, X); }, false}, {Builtins::MUL(Word(-1), X), [=]() -> Pattern { return Builtins::SUB(0, X); }},
{Builtins::DIV(X, 0), [=]{ return Word(0); }, true}, {Builtins::DIV(X, 0), [=]{ return Word(0); }},
{Builtins::DIV(0, X), [=]{ return Word(0); }, true}, {Builtins::DIV(0, X), [=]{ return Word(0); }},
{Builtins::DIV(X, 1), [=]{ return X; }, false}, {Builtins::DIV(X, 1), [=]{ return X; }},
{Builtins::SDIV(X, 0), [=]{ return Word(0); }, true}, {Builtins::SDIV(X, 0), [=]{ return Word(0); }},
{Builtins::SDIV(0, X), [=]{ return Word(0); }, true}, {Builtins::SDIV(0, X), [=]{ return Word(0); }},
{Builtins::SDIV(X, 1), [=]{ return X; }, false}, {Builtins::SDIV(X, 1), [=]{ return X; }},
{Builtins::AND(X, ~Word(0)), [=]{ return X; }, false}, {Builtins::AND(X, ~Word(0)), [=]{ return X; }},
{Builtins::AND(~Word(0), X), [=]{ return X; }, false}, {Builtins::AND(~Word(0), X), [=]{ return X; }},
{Builtins::AND(X, 0), [=]{ return Word(0); }, true}, {Builtins::AND(X, 0), [=]{ return Word(0); }},
{Builtins::AND(0, X), [=]{ return Word(0); }, true}, {Builtins::AND(0, X), [=]{ return Word(0); }},
{Builtins::OR(X, 0), [=]{ return X; }, false}, {Builtins::OR(X, 0), [=]{ return X; }},
{Builtins::OR(0, X), [=]{ return X; }, false}, {Builtins::OR(0, X), [=]{ return X; }},
{Builtins::OR(X, ~Word(0)), [=]{ return ~Word(0); }, true}, {Builtins::OR(X, ~Word(0)), [=]{ return ~Word(0); }},
{Builtins::OR(~Word(0), X), [=]{ return ~Word(0); }, true}, {Builtins::OR(~Word(0), X), [=]{ return ~Word(0); }},
{Builtins::XOR(X, 0), [=]{ return X; }, false}, {Builtins::XOR(X, 0), [=]{ return X; }},
{Builtins::XOR(0, X), [=]{ return X; }, false}, {Builtins::XOR(0, X), [=]{ return X; }},
{Builtins::MOD(X, 0), [=]{ return Word(0); }, true}, {Builtins::MOD(X, 0), [=]{ return Word(0); }},
{Builtins::MOD(0, X), [=]{ return Word(0); }, true}, {Builtins::MOD(0, X), [=]{ return Word(0); }},
{Builtins::EQ(X, 0), [=]() -> Pattern { return Builtins::ISZERO(X); }, false }, {Builtins::EQ(X, 0), [=]() -> Pattern { return Builtins::ISZERO(X); },},
{Builtins::EQ(0, X), [=]() -> Pattern { return Builtins::ISZERO(X); }, false }, {Builtins::EQ(0, X), [=]() -> Pattern { return Builtins::ISZERO(X); },},
{Builtins::SHL(0, X), [=]{ return X; }, false}, {Builtins::SHL(0, X), [=]{ return X; }},
{Builtins::SHR(0, X), [=]{ return X; }, false}, {Builtins::SHR(0, X), [=]{ return X; }},
{Builtins::SHL(X, 0), [=]{ return Word(0); }, true}, {Builtins::SHL(X, 0), [=]{ return Word(0); }},
{Builtins::SHR(X, 0), [=]{ return Word(0); }, true}, {Builtins::SHR(X, 0), [=]{ return Word(0); }},
{Builtins::GT(X, 0), [=]() -> Pattern { return Builtins::ISZERO(Builtins::ISZERO(X)); }, false}, {Builtins::GT(X, 0), [=]() -> Pattern { return Builtins::ISZERO(Builtins::ISZERO(X)); }},
{Builtins::LT(0, X), [=]() -> Pattern { return Builtins::ISZERO(Builtins::ISZERO(X)); }, false}, {Builtins::LT(0, X), [=]() -> Pattern { return Builtins::ISZERO(Builtins::ISZERO(X)); }},
{Builtins::GT(X, ~Word(0)), [=]{ return Word(0); }, true}, {Builtins::GT(X, ~Word(0)), [=]{ return Word(0); }},
{Builtins::LT(~Word(0), X), [=]{ return Word(0); }, true}, {Builtins::LT(~Word(0), X), [=]{ return Word(0); }},
{Builtins::GT(0, X), [=]{ return Word(0); }, true}, {Builtins::GT(0, X), [=]{ return Word(0); }},
{Builtins::LT(X, 0), [=]{ return Word(0); }, true}, {Builtins::LT(X, 0), [=]{ return Word(0); }},
{Builtins::AND(Builtins::BYTE(X, Y), Word(0xff)), [=]() -> Pattern { return Builtins::BYTE(X, Y); }, false}, {Builtins::AND(Builtins::BYTE(X, Y), Word(0xff)), [=]() -> Pattern { return Builtins::BYTE(X, Y); }},
{Builtins::BYTE(Word(Pattern::WordSize / 8 - 1), X), [=]() -> Pattern { return Builtins::AND(X, Word(0xff)); }, false} {Builtins::BYTE(Word(Pattern::WordSize / 8 - 1), X), [=]() -> Pattern { return Builtins::AND(X, Word(0xff)); }},
}; };
} }
@ -191,16 +191,16 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart3(
using Builtins = typename Pattern::Builtins; using Builtins = typename Pattern::Builtins;
return std::vector<SimplificationRule<Pattern>> { return std::vector<SimplificationRule<Pattern>> {
// operations involving an expression and itself // operations involving an expression and itself
{Builtins::AND(X, X), [=]{ return X; }, true}, {Builtins::AND(X, X), [=]{ return X; }},
{Builtins::OR(X, X), [=]{ return X; }, true}, {Builtins::OR(X, X), [=]{ return X; }},
{Builtins::XOR(X, X), [=]{ return Word(0); }, true}, {Builtins::XOR(X, X), [=]{ return Word(0); }},
{Builtins::SUB(X, X), [=]{ return Word(0); }, true}, {Builtins::SUB(X, X), [=]{ return Word(0); }},
{Builtins::EQ(X, X), [=]{ return Word(1); }, true}, {Builtins::EQ(X, X), [=]{ return Word(1); }},
{Builtins::LT(X, X), [=]{ return Word(0); }, true}, {Builtins::LT(X, X), [=]{ return Word(0); }},
{Builtins::SLT(X, X), [=]{ return Word(0); }, true}, {Builtins::SLT(X, X), [=]{ return Word(0); }},
{Builtins::GT(X, X), [=]{ return Word(0); }, true}, {Builtins::GT(X, X), [=]{ return Word(0); }},
{Builtins::SGT(X, X), [=]{ return Word(0); }, true}, {Builtins::SGT(X, X), [=]{ return Word(0); }},
{Builtins::MOD(X, X), [=]{ return Word(0); }, true} {Builtins::MOD(X, X), [=]{ return Word(0); }}
}; };
} }
@ -217,23 +217,23 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart4(
using Builtins = typename Pattern::Builtins; using Builtins = typename Pattern::Builtins;
return std::vector<SimplificationRule<Pattern>> { return std::vector<SimplificationRule<Pattern>> {
// logical instruction combinations // logical instruction combinations
{Builtins::NOT(Builtins::NOT(X)), [=]{ return X; }, false}, {Builtins::NOT(Builtins::NOT(X)), [=]{ return X; }},
{Builtins::XOR(X, Builtins::XOR(X, Y)), [=]{ return Y; }, true}, {Builtins::XOR(X, Builtins::XOR(X, Y)), [=]{ return Y; }},
{Builtins::XOR(X, Builtins::XOR(Y, X)), [=]{ return Y; }, true}, {Builtins::XOR(X, Builtins::XOR(Y, X)), [=]{ return Y; }},
{Builtins::XOR(Builtins::XOR(X, Y), X), [=]{ return Y; }, true}, {Builtins::XOR(Builtins::XOR(X, Y), X), [=]{ return Y; }},
{Builtins::XOR(Builtins::XOR(Y, X), X), [=]{ return Y; }, true}, {Builtins::XOR(Builtins::XOR(Y, X), X), [=]{ return Y; }},
{Builtins::OR(X, Builtins::AND(X, Y)), [=]{ return X; }, true}, {Builtins::OR(X, Builtins::AND(X, Y)), [=]{ return X; }},
{Builtins::OR(X, Builtins::AND(Y, X)), [=]{ return X; }, true}, {Builtins::OR(X, Builtins::AND(Y, X)), [=]{ return X; }},
{Builtins::OR(Builtins::AND(X, Y), X), [=]{ return X; }, true}, {Builtins::OR(Builtins::AND(X, Y), X), [=]{ return X; }},
{Builtins::OR(Builtins::AND(Y, X), X), [=]{ return X; }, true}, {Builtins::OR(Builtins::AND(Y, X), X), [=]{ return X; }},
{Builtins::AND(X, Builtins::OR(X, Y)), [=]{ return X; }, true}, {Builtins::AND(X, Builtins::OR(X, Y)), [=]{ return X; }},
{Builtins::AND(X, Builtins::OR(Y, X)), [=]{ return X; }, true}, {Builtins::AND(X, Builtins::OR(Y, X)), [=]{ return X; }},
{Builtins::AND(Builtins::OR(X, Y), X), [=]{ return X; }, true}, {Builtins::AND(Builtins::OR(X, Y), X), [=]{ return X; }},
{Builtins::AND(Builtins::OR(Y, X), X), [=]{ return X; }, true}, {Builtins::AND(Builtins::OR(Y, X), X), [=]{ return X; }},
{Builtins::AND(X, Builtins::NOT(X)), [=]{ return Word(0); }, true}, {Builtins::AND(X, Builtins::NOT(X)), [=]{ return Word(0); }},
{Builtins::AND(Builtins::NOT(X), X), [=]{ return Word(0); }, true}, {Builtins::AND(Builtins::NOT(X), X), [=]{ return Word(0); }},
{Builtins::OR(X, Builtins::NOT(X)), [=]{ return ~Word(0); }, true}, {Builtins::OR(X, Builtins::NOT(X)), [=]{ return ~Word(0); }},
{Builtins::OR(Builtins::NOT(X), X), [=]{ return ~Word(0); }, true}, {Builtins::OR(Builtins::NOT(X), X), [=]{ return ~Word(0); }},
}; };
} }
@ -249,14 +249,14 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart4_5(
using Builtins = typename Pattern::Builtins; using Builtins = typename Pattern::Builtins;
return std::vector<SimplificationRule<Pattern>>{ return std::vector<SimplificationRule<Pattern>>{
// idempotent operations // idempotent operations
{Builtins::AND(Builtins::AND(X, Y), Y), [=]{ return Builtins::AND(X, Y); }, true}, {Builtins::AND(Builtins::AND(X, Y), Y), [=]{ return Builtins::AND(X, Y); }},
{Builtins::AND(Y, Builtins::AND(X, Y)), [=]{ return Builtins::AND(X, Y); }, true}, {Builtins::AND(Y, Builtins::AND(X, Y)), [=]{ return Builtins::AND(X, Y); }},
{Builtins::AND(Builtins::AND(Y, X), Y), [=]{ return Builtins::AND(Y, X); }, true}, {Builtins::AND(Builtins::AND(Y, X), Y), [=]{ return Builtins::AND(Y, X); }},
{Builtins::AND(Y, Builtins::AND(Y, X)), [=]{ return Builtins::AND(Y, X); }, true}, {Builtins::AND(Y, Builtins::AND(Y, X)), [=]{ return Builtins::AND(Y, X); }},
{Builtins::OR(Builtins::OR(X, Y), Y), [=]{ return Builtins::OR(X, Y); }, true}, {Builtins::OR(Builtins::OR(X, Y), Y), [=]{ return Builtins::OR(X, Y); }},
{Builtins::OR(Y, Builtins::OR(X, Y)), [=]{ return Builtins::OR(X, Y); }, true}, {Builtins::OR(Y, Builtins::OR(X, Y)), [=]{ return Builtins::OR(X, Y); }},
{Builtins::OR(Builtins::OR(Y, X), Y), [=]{ return Builtins::OR(Y, X); }, true}, {Builtins::OR(Builtins::OR(Y, X), Y), [=]{ return Builtins::OR(Y, X); }},
{Builtins::OR(Y, Builtins::OR(Y, X)), [=]{ return Builtins::OR(Y, X); }, true}, {Builtins::OR(Y, Builtins::OR(Y, X)), [=]{ return Builtins::OR(Y, X); }},
}; };
} }
@ -280,8 +280,7 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart5(
Word value = Word(1) << i; Word value = Word(1) << i;
rules.push_back({ rules.push_back({
Builtins::MOD(X, value), Builtins::MOD(X, value),
[=]() -> Pattern { return Builtins::AND(X, value - 1); }, [=]() -> Pattern { return Builtins::AND(X, value - 1); }
false
}); });
} }
@ -289,7 +288,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart5(
rules.push_back({ rules.push_back({
Builtins::SHL(A, X), Builtins::SHL(A, X),
[=]() -> Pattern { return Word(0); }, [=]() -> Pattern { return Word(0); },
true,
[=]() { return A.d() >= Pattern::WordSize; } [=]() { return A.d() >= Pattern::WordSize; }
}); });
@ -297,7 +295,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart5(
rules.push_back({ rules.push_back({
Builtins::SHR(A, X), Builtins::SHR(A, X),
[=]() -> Pattern { return Word(0); }, [=]() -> Pattern { return Word(0); },
true,
[=]() { return A.d() >= Pattern::WordSize; } [=]() { return A.d() >= Pattern::WordSize; }
}); });
@ -305,7 +302,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart5(
rules.push_back({ rules.push_back({
Builtins::BYTE(A, X), Builtins::BYTE(A, X),
[=]() -> Pattern { return Word(0); }, [=]() -> Pattern { return Word(0); },
true,
[=]() { return A.d() >= Pattern::WordSize / 8; } [=]() { return A.d() >= Pattern::WordSize / 8; }
}); });
@ -320,13 +316,11 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart5(
Word const mask = (Word(1) << 160) - 1; Word const mask = (Word(1) << 160) - 1;
rules.push_back({ rules.push_back({
Builtins::AND(Pattern{instr}, mask), Builtins::AND(Pattern{instr}, mask),
[=]() -> Pattern { return {instr}; }, [=]() -> Pattern { return {instr}; }
false
}); });
rules.push_back({ rules.push_back({
Builtins::AND(mask, Pattern{instr}), Builtins::AND(mask, Pattern{instr}),
[=]() -> Pattern { return {instr}; }, [=]() -> Pattern { return {instr}; }
false
}); });
} }
@ -357,21 +351,18 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart6(
typename Builtins::PatternGeneratorInstance op{instr}; typename Builtins::PatternGeneratorInstance op{instr};
rules.push_back({ rules.push_back({
Builtins::ISZERO(Builtins::ISZERO(op(X, Y))), Builtins::ISZERO(Builtins::ISZERO(op(X, Y))),
[=]() -> Pattern { return op(X, Y); }, [=]() -> Pattern { return op(X, Y); }
false
}); });
} }
rules.push_back({ rules.push_back({
Builtins::ISZERO(Builtins::ISZERO(Builtins::ISZERO(X))), Builtins::ISZERO(Builtins::ISZERO(Builtins::ISZERO(X))),
[=]() -> Pattern { return Builtins::ISZERO(X); }, [=]() -> Pattern { return Builtins::ISZERO(X); }
false
}); });
rules.push_back({ rules.push_back({
Builtins::ISZERO(Builtins::XOR(X, Y)), Builtins::ISZERO(Builtins::XOR(X, Y)),
[=]() -> Pattern { return Builtins::EQ(X, Y); }, [=]() -> Pattern { return Builtins::EQ(X, Y); }
false
}); });
return rules; return rules;
@ -409,23 +400,19 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
rules += std::vector<SimplificationRule<Pattern>>{{ rules += std::vector<SimplificationRule<Pattern>>{{
// (X+A)+B -> X+(A+B) // (X+A)+B -> X+(A+B)
op(opXA, B), op(opXA, B),
[=]() -> Pattern { return op(X, fun(A.d(), B.d())); }, [=]() -> Pattern { return op(X, fun(A.d(), B.d())); }
false
}, { }, {
// (X+A)+Y -> (X+Y)+A // (X+A)+Y -> (X+Y)+A
op(opXA, Y), op(opXA, Y),
[=]() -> Pattern { return op(op(X, Y), A); }, [=]() -> Pattern { return op(op(X, Y), A); }
false
}, { }, {
// B+(X+A) -> X+(A+B) // B+(X+A) -> X+(A+B)
op(B, opXA), op(B, opXA),
[=]() -> Pattern { return op(X, fun(A.d(), B.d())); }, [=]() -> Pattern { return op(X, fun(A.d(), B.d())); }
false
}, { }, {
// Y+(X+A) -> (Y+X)+A // Y+(X+A) -> (Y+X)+A
op(Y, opXA), op(Y, opXA),
[=]() -> Pattern { return op(op(Y, X), A); }, [=]() -> Pattern { return op(op(Y, X), A); }
false
}}; }};
} }
} }
@ -440,8 +427,7 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
return Builtins::AND(X, Word(0)); return Builtins::AND(X, Word(0));
else else
return Builtins::SHL(Word(sum), X); return Builtins::SHL(Word(sum), X);
}, }
false
}); });
// Combine two SHR by constant // Combine two SHR by constant
@ -454,8 +440,7 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
return Builtins::AND(X, Word(0)); return Builtins::AND(X, Word(0));
else else
return Builtins::SHR(Word(sum), X); return Builtins::SHR(Word(sum), X);
}, }
false
}); });
// Combine SHL-SHR by constant // Combine SHL-SHR by constant
@ -472,7 +457,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
else else
return Builtins::AND(X, mask); return Builtins::AND(X, mask);
}, },
false,
[=] { return A.d() < Pattern::WordSize && B.d() < Pattern::WordSize; } [=] { return A.d() < Pattern::WordSize && B.d() < Pattern::WordSize; }
}); });
@ -490,7 +474,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
else else
return Builtins::AND(X, mask); return Builtins::AND(X, mask);
}, },
false,
[=] { return A.d() < Pattern::WordSize && B.d() < Pattern::WordSize; } [=] { return A.d() < Pattern::WordSize && B.d() < Pattern::WordSize; }
}); });
@ -509,14 +492,12 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
// SH[L/R](B, AND(X, A)) -> AND(SH[L/R](B, X), [ A << B / A >> B ]) // SH[L/R](B, AND(X, A)) -> AND(SH[L/R](B, X), [ A << B / A >> B ])
shiftOp(B, Builtins::AND(X, A)), shiftOp(B, Builtins::AND(X, A)),
replacement, replacement,
false,
[=] { return B.d() < Pattern::WordSize; } [=] { return B.d() < Pattern::WordSize; }
}); });
rules.push_back({ rules.push_back({
// SH[L/R](B, AND(A, X)) -> AND(SH[L/R](B, X), [ A << B / A >> B ]) // SH[L/R](B, AND(A, X)) -> AND(SH[L/R](B, X), [ A << B / A >> B ])
shiftOp(B, Builtins::AND(A, X)), shiftOp(B, Builtins::AND(A, X)),
replacement, replacement,
false,
[=] { return B.d() < Pattern::WordSize; } [=] { return B.d() < Pattern::WordSize; }
}); });
} }
@ -526,17 +507,14 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
Builtins::MUL(X, Builtins::SHL(Y, Word(1))), Builtins::MUL(X, Builtins::SHL(Y, Word(1))),
[=]() -> Pattern { [=]() -> Pattern {
return Builtins::SHL(Y, X); return Builtins::SHL(Y, X);
}, }
// Actually only changes the order, does not remove.
true
}); });
rules.push_back({ rules.push_back({
// MUL(SHL(X, 1), Y) -> SHL(X, Y) // MUL(SHL(X, 1), Y) -> SHL(X, Y)
Builtins::MUL(Builtins::SHL(X, Word(1)), Y), Builtins::MUL(Builtins::SHL(X, Word(1)), Y),
[=]() -> Pattern { [=]() -> Pattern {
return Builtins::SHL(X, Y); return Builtins::SHL(X, Y);
}, }
false
}); });
rules.push_back({ rules.push_back({
@ -544,9 +522,7 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
Builtins::DIV(X, Builtins::SHL(Y, Word(1))), Builtins::DIV(X, Builtins::SHL(Y, Word(1))),
[=]() -> Pattern { [=]() -> Pattern {
return Builtins::SHR(Y, X); return Builtins::SHR(Y, X);
}, }
// Actually only changes the order, does not remove.
true
}); });
std::function<bool()> feasibilityFunction = [=]() { std::function<bool()> feasibilityFunction = [=]() {
@ -560,7 +536,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
// AND(A, SHR(B, X)) -> A & ((2^256-1) >> B) == ((2^256-1) >> B) // AND(A, SHR(B, X)) -> A & ((2^256-1) >> B) == ((2^256-1) >> B)
Builtins::AND(A, Builtins::SHR(B, X)), Builtins::AND(A, Builtins::SHR(B, X)),
[=]() -> Pattern { return Builtins::SHR(B, X); }, [=]() -> Pattern { return Builtins::SHR(B, X); },
false,
feasibilityFunction feasibilityFunction
}); });
@ -568,28 +543,24 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart7(
// AND(SHR(B, X), A) -> ((2^256-1) >> B) & A == ((2^256-1) >> B) // AND(SHR(B, X), A) -> ((2^256-1) >> B) & A == ((2^256-1) >> B)
Builtins::AND(Builtins::SHR(B, X), A), Builtins::AND(Builtins::SHR(B, X), A),
[=]() -> Pattern { return Builtins::SHR(B, X); }, [=]() -> Pattern { return Builtins::SHR(B, X); },
false,
feasibilityFunction feasibilityFunction
}); });
rules.push_back({ rules.push_back({
Builtins::BYTE(A, Builtins::SHL(B, X)), Builtins::BYTE(A, Builtins::SHL(B, X)),
[=]() -> Pattern { return Builtins::BYTE(A.d() + B.d() / 8, X); }, [=]() -> Pattern { return Builtins::BYTE(A.d() + B.d() / 8, X); },
false,
[=] { return B.d() % 8 == 0 && A.d() <= 32 && B.d() <= 256; } [=] { return B.d() % 8 == 0 && A.d() <= 32 && B.d() <= 256; }
}); });
rules.push_back({ rules.push_back({
Builtins::BYTE(A, Builtins::SHR(B, X)), Builtins::BYTE(A, Builtins::SHR(B, X)),
[=]() -> Pattern { return Word(0); }, [=]() -> Pattern { return Word(0); },
true,
[=] { return A.d() < B.d() / 8; } [=] { return A.d() < B.d() / 8; }
}); });
rules.push_back({ rules.push_back({
Builtins::BYTE(A, Builtins::SHR(B, X)), Builtins::BYTE(A, Builtins::SHR(B, X)),
[=]() -> Pattern { return Builtins::BYTE(A.d() - B.d() / 8, X); }, [=]() -> Pattern { return Builtins::BYTE(A.d() - B.d() / 8, X); },
false,
[=] { [=] {
return B.d() % 8 == 0 && A.d() < Pattern::WordSize / 8 && B.d() <= Pattern::WordSize && A.d() >= B.d() / 8; return B.d() % 8 == 0 && A.d() < Pattern::WordSize / 8 && B.d() <= Pattern::WordSize && A.d() >= B.d() / 8;
} }
@ -615,76 +586,28 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleListPart8(
{ {
// X - A -> X + (-A) // X - A -> X + (-A)
Builtins::SUB(X, A), Builtins::SUB(X, A),
[=]() -> Pattern { return Builtins::ADD(X, 0 - A.d()); }, [=]() -> Pattern { return Builtins::ADD(X, 0 - A.d()); }
false
}, { }, {
// (X + A) - Y -> (X - Y) + A // (X + A) - Y -> (X - Y) + A
Builtins::SUB(Builtins::ADD(X, A), Y), Builtins::SUB(Builtins::ADD(X, A), Y),
[=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), A); }, [=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), A); }
false
}, { }, {
// (A + X) - Y -> (X - Y) + A // (A + X) - Y -> (X - Y) + A
Builtins::SUB(Builtins::ADD(A, X), Y), Builtins::SUB(Builtins::ADD(A, X), Y),
[=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), A); }, [=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), A); }
false
}, { }, {
// X - (Y + A) -> (X - Y) + (-A) // X - (Y + A) -> (X - Y) + (-A)
Builtins::SUB(X, Builtins::ADD(Y, A)), Builtins::SUB(X, Builtins::ADD(Y, A)),
[=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), 0 - A.d()); }, [=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), 0 - A.d()); }
false
}, { }, {
// X - (A + Y) -> (X - Y) + (-A) // X - (A + Y) -> (X - Y) + (-A)
Builtins::SUB(X, Builtins::ADD(A, Y)), Builtins::SUB(X, Builtins::ADD(A, Y)),
[=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), 0 - A.d()); }, [=]() -> Pattern { return Builtins::ADD(Builtins::SUB(X, Y), 0 - A.d()); }
false
} }
}; };
return rules; return rules;
} }
template <class Pattern>
std::vector<SimplificationRule<Pattern>> simplificationRuleListPart9(
Pattern,
Pattern,
Pattern,
Pattern W,
Pattern X,
Pattern Y,
Pattern Z
)
{
using Word = typename Pattern::Word;
using Builtins = typename Pattern::Builtins;
std::vector<SimplificationRule<Pattern>> rules;
assertThrow(Pattern::WordSize > 160, OptimizerException, "");
Word const mask = (Word(1) << 160) - 1;
// CREATE
rules.push_back({
Builtins::AND(Builtins::CREATE(W, X, Y), mask),
[=]() -> Pattern { return Builtins::CREATE(W, X, Y); },
false
});
rules.push_back({
Builtins::AND(mask, Builtins::CREATE(W, X, Y)),
[=]() -> Pattern { return Builtins::CREATE(W, X, Y); },
false
});
// CREATE2
rules.push_back({
Builtins::AND(Builtins::CREATE2(W, X, Y, Z), mask),
[=]() -> Pattern { return Builtins::CREATE2(W, X, Y, Z); },
false
});
rules.push_back({
Builtins::AND(mask, Builtins::CREATE2(W, X, Y, Z)),
[=]() -> Pattern { return Builtins::CREATE2(W, X, Y, Z); },
false
});
return rules;
}
template<class Pattern> template<class Pattern>
std::vector<SimplificationRule<Pattern>> evmRuleList( std::vector<SimplificationRule<Pattern>> evmRuleList(
langutil::EVMVersion _evmVersion, langutil::EVMVersion _evmVersion,
@ -703,7 +626,7 @@ std::vector<SimplificationRule<Pattern>> evmRuleList(
if (_evmVersion.hasSelfBalance()) if (_evmVersion.hasSelfBalance())
rules.push_back({ rules.push_back({
Builtins::BALANCE(Instruction::ADDRESS), Builtins::BALANCE(Instruction::ADDRESS),
[]() -> Pattern { return Instruction::SELFBALANCE; }, false []() -> Pattern { return Instruction::SELFBALANCE; }
}); });
return rules; return rules;
@ -743,7 +666,6 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleList(
rules += simplificationRuleListPart6(A, B, C, W, X); rules += simplificationRuleListPart6(A, B, C, W, X);
rules += simplificationRuleListPart7(A, B, C, W, X); rules += simplificationRuleListPart7(A, B, C, W, X);
rules += simplificationRuleListPart8(A, B, C, W, X); rules += simplificationRuleListPart8(A, B, C, W, X);
rules += simplificationRuleListPart9(A, B, C, W, X, Y, Z);
if (_evmVersion.has_value()) if (_evmVersion.has_value())
rules += evmRuleList(*_evmVersion, A, B, C, W, X, Y, Z); rules += evmRuleList(*_evmVersion, A, B, C, W, X, Y, Z);

8
libevmasm/SimplificationRule.h
View File

@ -30,9 +30,8 @@ namespace solidity::evmasm
/** /**
* Rule that contains a pattern, an action that can be applied * Rule that contains a pattern, an action that can be applied
* after the pattern has matched and a bool that indicates * after the pattern has matched and optional condition to check if the
* whether the action would remove something from the expression * action should be applied.
* than is not a constant literal.
*/ */
template <class Pattern> template <class Pattern>
struct SimplificationRule struct SimplificationRule
@ -40,18 +39,15 @@ struct SimplificationRule
SimplificationRule( SimplificationRule(
Pattern _pattern, Pattern _pattern,
std::function<Pattern()> _action, std::function<Pattern()> _action,
bool _removesNonConstants,
std::function<bool()> _feasible = {} std::function<bool()> _feasible = {}
): ):
pattern(std::move(_pattern)), pattern(std::move(_pattern)),
action(std::move(_action)), action(std::move(_action)),
removesNonConstants(_removesNonConstants),
feasible(std::move(_feasible)) feasible(std::move(_feasible))
{} {}
Pattern pattern; Pattern pattern;
std::function<Pattern()> action; std::function<Pattern()> action;
bool removesNonConstants;
std::function<bool()> feasible; std::function<bool()> feasible;
}; };

15
libyul/optimiser/ExpressionSimplifier.cpp
View File

@ -22,12 +22,9 @@
#include <libyul/optimiser/ExpressionSimplifier.h> #include <libyul/optimiser/ExpressionSimplifier.h>
#include <libyul/optimiser/SimplificationRules.h> #include <libyul/optimiser/SimplificationRules.h>
#include <libyul/optimiser/Semantics.h>
#include <libyul/optimiser/OptimiserStep.h> #include <libyul/optimiser/OptimiserStep.h>
#include <libyul/AsmData.h> #include <libyul/AsmData.h>
#include <libsolutil/CommonData.h>
using namespace std; using namespace std;
using namespace solidity; using namespace solidity;
using namespace solidity::yul; using namespace solidity::yul;
@ -40,17 +37,7 @@ void ExpressionSimplifier::run(OptimiserStepContext& _context, Block& _ast)
void ExpressionSimplifier::visit(Expression& _expression) void ExpressionSimplifier::visit(Expression& _expression)
{ {
ASTModifier::visit(_expression); ASTModifier::visit(_expression);
while (auto match = SimplificationRules::findFirstMatch(_expression, m_dialect, m_value))
{
// Do not apply the rule if it removes non-constant parts of the expression.
// TODO: The check could actually be less strict than "movable".
// We only require "Does not cause side-effects".
// Note: References to variables that are only assigned once are always movable,
// so if the value of the variable is not movable, the expression that references
// the variable still is.
if (match->removesNonConstants && !SideEffectsCollector(m_dialect, _expression).movable()) while (auto const* match = SimplificationRules::findFirstMatch(_expression, m_dialect, m_value))
return;
_expression = match->action().toExpression(locationOf(_expression)); _expression = match->action().toExpression(locationOf(_expression));
} }
}

3
libyul/optimiser/ExpressionSimplifier.h
View File

@ -33,7 +33,8 @@ struct OptimiserStepContext;
/** /**
* Applies simplification rules to all expressions. * Applies simplification rules to all expressions.
* The component will work best if the code is in SSA form, but * The component will work best if the code is in SSA form, but
* this is not required for correctness. * this is not required for correctness. Using CommonSubexpressionEliminator
* also helps this component track equivalent sub-expressions.
* *
* It tracks the current values of variables using the DataFlowAnalyzer * It tracks the current values of variables using the DataFlowAnalyzer
* and takes them into account for replacements. * and takes them into account for replacements.

23
libyul/optimiser/SimplificationRules.cpp
View File

@ -171,12 +171,22 @@ bool Pattern::matches(
return false; return false;
assertThrow(m_arguments.size() == instrAndArgs->second->size(), OptimizerException, ""); assertThrow(m_arguments.size() == instrAndArgs->second->size(), OptimizerException, "");
for (size_t i = 0; i < m_arguments.size(); ++i) for (size_t i = 0; i < m_arguments.size(); ++i)
if (!m_arguments[i].matches(instrAndArgs->second->at(i), _dialect, _ssaValues)) {
Expression const& arg = instrAndArgs->second->at(i);
// If this is a direct function call instead of a variable or literal,
// we reject the match because side-effects could prevent us from
// arbitrarily modifying the code.
if (
holds_alternative<FunctionCall>(arg) ||
!m_arguments[i].matches(arg, _dialect, _ssaValues)
)
return false; return false;
} }
}
else else
{ {
assertThrow(m_arguments.empty(), OptimizerException, "\"Any\" should not have arguments."); assertThrow(m_arguments.empty(), OptimizerException, "\"Any\" should not have arguments.");
assertThrow(!holds_alternative<FunctionCall>(*expr), OptimizerException, "\"Any\" at top-level.");
} }
if (m_matchGroup) if (m_matchGroup)
@ -197,9 +207,14 @@ bool Pattern::matches(
assertThrow(m_kind == PatternKind::Any, OptimizerException, "Match group repetition for non-any."); assertThrow(m_kind == PatternKind::Any, OptimizerException, "Match group repetition for non-any.");
Expression const* firstMatch = (*m_matchGroups)[m_matchGroup]; Expression const* firstMatch = (*m_matchGroups)[m_matchGroup];
assertThrow(firstMatch, OptimizerException, "Match set but to null."); assertThrow(firstMatch, OptimizerException, "Match set but to null.");
return assertThrow(
SyntacticallyEqual{}(*firstMatch, _expr) && !holds_alternative<FunctionCall>(_expr) &&
SideEffectsCollector(_dialect, _expr).movable(); !holds_alternative<FunctionCall>(*firstMatch),
OptimizerException,
"Group matches have to be literals or variables."
);
return SyntacticallyEqual{}(*firstMatch, _expr);
} }
else if (m_kind == PatternKind::Any) else if (m_kind == PatternKind::Any)
(*m_matchGroups)[m_matchGroup] = &_expr; (*m_matchGroups)[m_matchGroup] = &_expr;

5
test/libyul/YulOptimizerTest.cpp
View File

@ -225,9 +225,14 @@ TestCase::TestResult YulOptimizerTest::run(ostream& _stream, string const& _line
else if (m_optimizerStep == "expressionSimplifier") else if (m_optimizerStep == "expressionSimplifier")
{ {
disambiguate(); disambiguate();
ExpressionSplitter::run(*m_context, *m_object->code);
CommonSubexpressionEliminator::run(*m_context, *m_object->code);
ExpressionSimplifier::run(*m_context, *m_object->code); ExpressionSimplifier::run(*m_context, *m_object->code);
ExpressionSimplifier::run(*m_context, *m_object->code); ExpressionSimplifier::run(*m_context, *m_object->code);
ExpressionSimplifier::run(*m_context, *m_object->code); ExpressionSimplifier::run(*m_context, *m_object->code);
UnusedPruner::run(*m_context, *m_object->code);
ExpressionJoiner::run(*m_context, *m_object->code);
ExpressionJoiner::run(*m_context, *m_object->code);
} }
else if (m_optimizerStep == "fullSimplify") else if (m_optimizerStep == "fullSimplify")
{ {

3
test/libyul/yulOptimizerTests/expressionSimplifier/assigned_vars_multi.yul
View File

@ -2,6 +2,7 @@
function f() -> x, z {} function f() -> x, z {}
let c, d := f() let c, d := f()
let y := add(d, add(c, 7)) let y := add(d, add(c, 7))
sstore(y, 20)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
@ -10,5 +11,5 @@
// function f() -> x, z // function f() -> x, z
// { } // { }
// let c, d := f() // let c, d := f()
// let y := add(add(d, c), 7) // sstore(add(add(d, c), 7), 20)
// } // }

8
test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and.yul
View File

@ -1,7 +1,11 @@
{ {
// This is not fully simplified on purpose because we
// need another split step in between. The full simplification
// is tested in the fullSuite.
let x := calldataload(0) let x := calldataload(0)
let a := and(0xff, shr(248, shl(248, shr(248, x)))) let a := and(0xff, shr(248, shl(248, shr(248, x))))
let b := shr(12, shl(8, and(x, 0xf0f0))) let b := shr(12, shl(8, and(x, 0xf0f0)))
sstore(a, b)
} }
// ==== // ====
// EVMVersion: >byzantium // EVMVersion: >byzantium
@ -10,6 +14,6 @@
// //
// { // {
// let x := calldataload(0) // let x := calldataload(0)
// let a := shr(248, x) // let a := and(0xff, and(shr(248, x), 255))
// let b := and(shr(4, x), 3855) // sstore(a, shr(12, and(shl(8, x), 15790080)))
// } // }

33
test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and_2.yul
View File

@ -1,4 +1,7 @@
{ {
// This is not fully simplified on purpose because we
// need another split step in between. The full simplification
// is tested in the fullSuite.
let x := calldataload(0) let x := calldataload(0)
let a := and(0xff, shr(248, shl(248, shr(248, and(x, 0xf))))) let a := and(0xff, shr(248, shl(248, shr(248, and(x, 0xf)))))
let b := shl(12, shr(4, and(x, 0xf0f0))) let b := shl(12, shr(4, and(x, 0xf0f0)))
@ -7,6 +10,13 @@
let e := shl(255, shr(4, and(0xf0f0, x))) let e := shl(255, shr(4, and(0xf0f0, x)))
let f := shl(12, shr(256, and(0xf0f0, x))) let f := shl(12, shr(256, and(0xf0f0, x)))
let g := shl(256, shr(4, and(0xf0f0, x))) let g := shl(256, shr(4, and(0xf0f0, x)))
sstore(10, a)
sstore(11, b)
sstore(12, c)
sstore(13, d)
sstore(14, e)
sstore(15, f)
sstore(16, g)
} }
// ==== // ====
// EVMVersion: >byzantium // EVMVersion: >byzantium
@ -15,11 +25,24 @@
// //
// { // {
// let x := calldataload(0) // let x := calldataload(0)
// let a := 0 // let _2 := 0xf
// let b := and(shl(8, x), 15790080) // let _5 := and(shr(248, x), 0)
// let c := and(shl(8, x), 15790080) // let _10 := 0xff
// let d := 0 // let a := and(_5, 255)
// let e := and(shl(251, x), 0x8000000000000000000000000000000000000000000000000000000000000000) // let _14 := and(shr(4, x), 3855)
// let _15 := 12
// let b := shl(_15, _14)
// let _19 := and(shr(4, x), 3855)
// let c := shl(_15, _19)
// let d := shl(_15, and(shr(255, x), 0))
// let e := shl(_10, _19)
// let f := 0 // let f := 0
// let g := 0 // let g := 0
// sstore(10, a)
// sstore(11, b)
// sstore(_15, c)
// sstore(13, d)
// sstore(14, e)
// sstore(_2, f)
// sstore(16, g)
// } // }

18
test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and_3.yul
View File

@ -1,10 +1,19 @@
{ {
// This is not fully simplified on purpose because we
// need another split step in between. The full simplification
// is tested in the fullSuite.
let x := calldataload(0) let x := calldataload(0)
let a := shl(12, shr(4, x)) let a := shl(12, shr(4, x))
let b := shl(4, shr(12, x)) let b := shl(4, shr(12, x))
let c := shr(12, shl(4, x)) let c := shr(12, shl(4, x))
let d := shr(4, shl(12, x)) let d := shr(4, shl(12, x))
let e := shl(150, shr(2, shl(150, x))) let e := shl(150, shr(2, shl(150, x)))
sstore(15, x)
sstore(16, a)
sstore(17, b)
sstore(18, c)
sstore(19, d)
sstore(20, e)
} }
// ==== // ====
// EVMVersion: >byzantium // EVMVersion: >byzantium
@ -17,5 +26,12 @@
// let b := and(shr(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0) // let b := and(shr(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0)
// let c := and(shr(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // let c := and(shr(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
// let d := and(shl(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) // let d := and(shl(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)
// let e := 0 // let _14 := 150
// let e := shl(_14, and(shl(148, x), 0x3ffffffffffffffffffffffffff0000000000000000000000000000000000000))
// sstore(15, x)
// sstore(16, a)
// sstore(17, b)
// sstore(18, c)
// sstore(19, d)
// sstore(20, e)
// } // }

7
test/libyul/yulOptimizerTests/expressionSimplifier/constant_propagation.yul
View File

@ -1,5 +1,8 @@
{ let a := add(7, sub(mload(0), 7)) } {
let a := add(7, sub(mload(0), 7))
mstore(20, a)
}
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { let a := mload(0) } // { mstore(20, mload(0)) }

7
test/libyul/yulOptimizerTests/expressionSimplifier/constants.yul
View File

@ -1,5 +1,8 @@
{ let a := add(1, mul(3, 4)) } {
let a := add(1, mul(3, 4))
sstore(7, a)
}
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { let a := 13 } // { sstore(7, 13) }

11
test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul
View File

@ -1,6 +1,10 @@
{ {
// This is not fully simplified on purpose because we
// need another split step in between. The full simplification
// is tested in the fullSuite.
let a := and(create2(0, 0, 0x20, 0), 0xffffffffffffffffffffffffffffffffffffffff) let a := and(create2(0, 0, 0x20, 0), 0xffffffffffffffffffffffffffffffffffffffff)
let b := and(0xffffffffffffffffffffffffffffffffffffffff, create2(0, 0, 0x20, 0)) let b := and(0xffffffffffffffffffffffffffffffffffffffff, create2(0, 0, 0x20, 0))
sstore(a, b)
} }
// ==== // ====
// EVMVersion: >=constantinople // EVMVersion: >=constantinople
@ -8,6 +12,9 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let a := create2(0, 0, 0x20, 0) // let _1 := 0xffffffffffffffffffffffffffffffffffffffff
// let b := create2(0, 0, 0x20, 0) // let _2 := 0
// let _3 := 0x20
// let a := and(create2(_2, _2, _3, _2), _1)
// sstore(a, and(_1, create2(_2, _2, _3, _2)))
// } // }

15
test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul
View File

@ -1,11 +1,20 @@
{ {
let a := and(create(0, 0, 0x20), 0xffffffffffffffffffffffffffffffffffffffff) // This is not fully simplified on purpose because we
// need another split step in between. The full simplification
// is tested in the fullSuite.
let c := create(0, 0, 0x20)
let a := and(c, 0xffffffffffffffffffffffffffffffffffffffff)
let b := and(0xffffffffffffffffffffffffffffffffffffffff, create(0, 0, 0x20)) let b := and(0xffffffffffffffffffffffffffffffffffffffff, create(0, 0, 0x20))
sstore(a, b)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let a := create(0, 0, 0x20) // let _1 := 0x20
// let b := create(0, 0, 0x20) // let _2 := 0
// let c := create(_2, _2, _1)
// let _4 := 0xffffffffffffffffffffffffffffffffffffffff
// let a := and(c, _4)
// sstore(a, and(_4, create(_2, _2, _1)))
// } // }

3
test/libyul/yulOptimizerTests/expressionSimplifier/idempotency.yul
View File

@ -3,6 +3,7 @@
let z := calldataload(1) let z := calldataload(1)
let t := and(and(x, z), x) let t := and(and(x, z), x)
let w := or(or(x, z), x) let w := or(or(x, z), x)
sstore(t, w)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
@ -11,5 +12,5 @@
// let x := calldataload(0) // let x := calldataload(0)
// let z := calldataload(1) // let z := calldataload(1)
// let t := and(x, z) // let t := and(x, z)
// let w := or(x, z) // sstore(t, or(x, z))
// } // }

7
test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_complex.yul
View File

@ -1,5 +1,8 @@
{ let a := sub(calldataload(0), calldataload(0)) } {
let a := sub(calldataload(0), calldataload(0))
sstore(0, a)
}
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { let a := 0 } // { sstore(0, 0) }

8
test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_negative.yul
View File

@ -1,7 +1,11 @@
{ let a := sub(calldataload(1), calldataload(0)) } {
let a := sub(calldataload(1), calldataload(0))
sstore(0, a)
}
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let a := sub(calldataload(1), calldataload(0)) // let _1 := 0
// sstore(_1, sub(calldataload(1), calldataload(_1)))
// } // }

6
test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_simple.yul
View File

@ -1,11 +1,9 @@
{ {
let a := mload(0) let a := mload(0)
let b := sub(a, a) let b := sub(a, a)
sstore(0, b)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // { sstore(0, 0) }
// let a := mload(0)
// let b := 0
// }

3
test/libyul/yulOptimizerTests/expressionSimplifier/including_function_calls.yul
View File

@ -1,6 +1,7 @@
{ {
function f() -> a {} function f() -> a {}
let b := add(7, sub(f(), 7)) let b := add(7, sub(f(), 7))
sstore(0, b)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
@ -8,5 +9,5 @@
// { // {
// function f() -> a // function f() -> a
// { } // { }
// let b := f() // sstore(0, f())
// } // }

6
test/libyul/yulOptimizerTests/expressionSimplifier/invariant.yul
View File

@ -1,11 +1,9 @@
{ {
let a := mload(sub(7, 7)) let a := mload(sub(7, 7))
let b := sub(a, 0) let b := sub(a, 0)
sstore(0, b)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // { sstore(0, mload(0)) }
// let a := mload(0)
// let b := a
// }

14
test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul
View File

@ -4,13 +4,23 @@
let c := byte(20, a) let c := byte(20, a)
// create cannot be removed. // create cannot be removed.
let d := byte(33, create(0, 0, 0x20)) let d := byte(33, create(0, 0, 0x20))
sstore(7, a)
sstore(8, b)
sstore(9, c)
sstore(10, d)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let a := calldataload(0) // let _1 := 0
// let a := calldataload(_1)
// let b := 0 // let b := 0
// let c := byte(20, a) // let c := byte(20, a)
// let d := byte(33, create(0, 0, 0x20)) // pop(create(_1, _1, 0x20))
// let d := 0
// sstore(7, a)
// sstore(8, b)
// sstore(9, c)
// sstore(10, d)
// } // }

3
test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_1.yul
View File

@ -5,5 +5,6 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// mstore(0, and(calldataload(0), 255)) // let _4 := 0
// mstore(_4, and(calldataload(_4), 255))
// } // }

3
test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_2.yul
View File

@ -5,5 +5,6 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// mstore(0, and(calldataload(0), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) // let _4 := 0
// mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
// } // }

5
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_arguments.yul
View File

@ -1,6 +1,7 @@
{ {
function f(a) -> b { } function f(a) -> b { }
let c := sub(f(0), f(1)) let c := sub(f(0), f(1))
sstore(0, c)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
@ -8,5 +9,7 @@
// { // {
// function f(a) -> b // function f(a) -> b
// { } // { }
// let c := sub(f(0), f(1)) // let _2 := f(1)
// let _3 := 0
// sstore(_3, sub(f(_3), _2))
// } // }

3
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_names.yul
View File

@ -2,6 +2,7 @@
function f1() -> a { } function f1() -> a { }
function f2() -> b { } function f2() -> b { }
let c := sub(f1(), f2()) let c := sub(f1(), f2())
sstore(0, c)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
@ -11,5 +12,5 @@
// { } // { }
// function f2() -> b // function f2() -> b
// { } // { }
// let c := sub(f1(), f2()) // sstore(0, sub(f1(), f2()))
// } // }

7
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_equality_not_movable.yul
View File

@ -1,13 +1,14 @@
// Even if the functions pass the equality check, they are not movable. // Even if the functions pass the equality check, they are not movable.
{ {
function f() -> a { } function f() -> a { mstore(0, 1) }
let b := sub(f(), f()) let b := sub(f(), f())
sstore(b, 8)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// function f() -> a // function f() -> a
// { } // { mstore(a, 1) }
// let b := sub(f(), f()) // sstore(sub(f(), f()), 8)
// } // }

8
test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_removes_non_constant_and_not_movable.yul
View File

@ -1,11 +1,17 @@
// The first argument of div is not constant. // The first argument of div is not constant.
// keccak256 is not movable. // keccak256 is not movable.
{ {
sstore(0, msize())
let a := div(keccak256(0, 0), 0) let a := div(keccak256(0, 0), 0)
sstore(20, a)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let a := div(keccak256(0, 0), 0) // let _1 := msize()
// let _2 := 0
// sstore(_2, _1)
// pop(keccak256(_2, _2))
// sstore(20, 0)
// } // }

6
test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul
View File

@ -1,5 +1,5 @@
{ {
pop(byte(0, shr(0x8, call(0, 0, 0, 0, 0, 0, 0)))) sstore(0, byte(0, shr(0x8, call(0, 0, 0, 0, 0, 0, 0))))
} }
// ==== // ====
// EVMVersion: >=constantinople // EVMVersion: >=constantinople
@ -7,5 +7,7 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// pop(byte(0, shr(0x8, call(0, 0, 0, 0, 0, 0, 0)))) // let _1 := 0
// pop(call(_1, _1, _1, _1, _1, _1, _1))
// sstore(_1, 0)
// } // }

7
test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_func.yul
View File

@ -1,6 +1,6 @@
{ {
function f() -> x { mstore(0, 1337) } function f() -> x { mstore(0, 1337) }
pop(byte(0, shr(0x8, f()))) mstore(0, byte(0, shr(0x8, f())))
} }
// ==== // ====
// EVMVersion: >=constantinople // EVMVersion: >=constantinople
@ -9,6 +9,7 @@
// //
// { // {
// function f() -> x // function f() -> x
// { mstore(0, 1337) } // { mstore(x, 1337) }
// pop(byte(0, shr(0x8, f()))) // pop(f())
// mstore(0, 0)
// } // }

8
test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_func_trivial.yul
View File

@ -1,14 +1,10 @@
{ {
function f() -> x {} function f() -> x {}
pop(byte(0, shr(0x8, f()))) sstore(0, byte(0, shr(0x8, f())))
} }
// ==== // ====
// EVMVersion: >=constantinople // EVMVersion: >=constantinople
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // { sstore(0, 0) }
// function f() -> x
// { }
// pop(byte(0, shr(0x8, f())))
// }

7
test/libyul/yulOptimizerTests/expressionSimplifier/reassign.yul
View File

@ -7,7 +7,8 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let x := mload(0) // let _1 := 0
// x := 0 // let x := mload(_1)
// mstore(0, 7) // x := _1
// mstore(_1, 7)
// } // }

14
test/libyul/yulOptimizerTests/expressionSimplifier/remove_redundant_shift_masking.yul
View File

@ -3,6 +3,8 @@
let b := and(shr(248, calldataload(0)), 0xff) let b := and(shr(248, calldataload(0)), 0xff)
let c := and(shr(249, calldataload(0)), 0xfa) let c := and(shr(249, calldataload(0)), 0xfa)
let d := and(shr(247, calldataload(0)), 0xff) let d := and(shr(247, calldataload(0)), 0xff)
sstore(a, b)
sstore(c, d)
} }
// ==== // ====
// EVMVersion: >=constantinople // EVMVersion: >=constantinople
@ -10,8 +12,12 @@
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let a := shr(248, calldataload(0)) // let _2 := calldataload(0)
// let b := shr(248, calldataload(0)) // let _5 := 0xff
// let c := and(shr(249, calldataload(0)), 0xfa) // let a := shr(248, _2)
// let d := and(shr(247, calldataload(0)), 0xff) // let b := shr(248, _2)
// let c := and(shr(249, _2), 0xfa)
// let d := and(shr(247, _2), _5)
// sstore(a, b)
// sstore(c, d)
// } // }

10
test/libyul/yulOptimizerTests/expressionSimplifier/replace_too_large_shift.yul
View File

@ -3,6 +3,8 @@
let b := shr(299, calldataload(1)) let b := shr(299, calldataload(1))
let c := shl(255, calldataload(2)) let c := shl(255, calldataload(2))
let d := shr(255, calldataload(3)) let d := shr(255, calldataload(3))
sstore(a, b)
sstore(c, d)
} }
// ==== // ====
// EVMVersion: >=constantinople // EVMVersion: >=constantinople
@ -12,6 +14,10 @@
// { // {
// let a := 0 // let a := 0
// let b := 0 // let b := 0
// let c := shl(255, calldataload(2)) // let _8 := calldataload(2)
// let d := shr(255, calldataload(3)) // let _9 := 255
// let c := shl(_9, _8)
// let d := shr(_9, calldataload(3))
// sstore(a, b)
// sstore(c, d)
// } // }

5
test/libyul/yulOptimizerTests/expressionSimplifier/return_vars_zero.yul
View File

@ -2,12 +2,15 @@
{ {
function f() -> c, d { function f() -> c, d {
let y := add(d, add(c, 7)) let y := add(d, add(c, 7))
sstore(0, y)
} }
let t, v := f()
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// function f() -> c, d // function f() -> c, d
// { let y := 7 } // { sstore(d, 7) }
// let t, v := f()
// } // }

6
test/libyul/yulOptimizerTests/expressionSimplifier/reversed.yul
View File

@ -1,7 +1,11 @@
{ {
let a := add(0, mload(0)) let a := add(0, mload(0))
sstore(0, a)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { let a := mload(0) } // {
// let _1 := 0
// sstore(_1, mload(_1))
// }

4
test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_not_supported.yul
View File

@ -1,9 +1,9 @@
{ {
let ret := balance(address()) sstore(0, balance(address()))
} }
// ==== // ====
// EVMVersion: <istanbul // EVMVersion: <istanbul
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { let ret := balance(address()) } // { sstore(0, balance(address())) }

3
test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_split.yul
View File

@ -1,6 +1,7 @@
{ {
let a := address() let a := address()
let ret := balance(a) let ret := balance(a)
sstore(a, ret)
} }
// ==== // ====
// EVMVersion: >=istanbul // EVMVersion: >=istanbul
@ -9,5 +10,5 @@
// //
// { // {
// let a := address() // let a := address()
// let ret := selfbalance() // sstore(a, selfbalance())
// } // }

4
test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_supported.yul
View File

@ -1,9 +1,9 @@
{ {
let ret := balance(address()) sstore(0, balance(address()))
} }
// ==== // ====
// EVMVersion: >=istanbul // EVMVersion: >=istanbul
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { let ret := selfbalance() } // { sstore(0, selfbalance()) }

3
test/libyul/yulOptimizerTests/expressionSimplifier/unassigend_vars_multi.yul
View File

@ -2,11 +2,12 @@
{ {
let c, d let c, d
let y := add(d, add(c, 7)) let y := add(d, add(c, 7))
sstore(0, y)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // {
// let c, d // let c, d
// let y := 7 // sstore(d, 7)
// } // }

7
test/libyul/yulOptimizerTests/expressionSimplifier/unassigned_vars.yul
View File

@ -3,12 +3,9 @@
let c let c
let d let d
let y := add(d, add(c, 7)) let y := add(d, add(c, 7))
sstore(8, y)
} }
// ---- // ----
// step: expressionSimplifier // step: expressionSimplifier
// //
// { // { sstore(8, 7) }
// let c
// let d
// let y := 7
// }

17
test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and.yul Normal file
View File

@ -0,0 +1,17 @@
{
let x := calldataload(0)
let a := and(0xff, shr(248, shl(248, shr(248, x))))
let b := shr(12, shl(8, and(x, 0xf0f0)))
sstore(a, b)
}
// ====
// EVMVersion: >byzantium
// ----
// step: fullSuite
//
// {
// {
// let x := calldataload(0)
// sstore(shr(248, x), and(shr(4, x), 3855))
// }
// }

35
test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_2.yul Normal file
View File

@ -0,0 +1,35 @@
{
let x := calldataload(0)
let a := and(0xff, shr(248, shl(248, shr(248, and(x, 0xf)))))
let b := shl(12, shr(4, and(x, 0xf0f0)))
let c := shl(12, shr(4, and(0xf0f0, x)))
let d := shl(12, shr(255, and(0xf0f0, x)))
let e := shl(255, shr(4, and(0xf0f0, x)))
let f := shl(12, shr(256, and(0xf0f0, x)))
let g := shl(256, shr(4, and(0xf0f0, x)))
sstore(10, a)
sstore(11, b)
sstore(12, c)
sstore(13, d)
sstore(14, e)
sstore(15, f)
sstore(16, g)
}
// ====
// EVMVersion: >byzantium
// ----
// step: fullSuite
//
// {
// {
// let x := calldataload(0)
// let b := and(shl(8, x), 15790080)
// sstore(10, 0)
// sstore(11, b)
// sstore(12, b)
// sstore(13, 0)
// sstore(14, and(shl(251, x), shl(255, 1)))
// sstore(0xf, 0)
// sstore(16, 0)
// }
// }

32
test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_3.yul Normal file
View File

@ -0,0 +1,32 @@
{
let x := calldataload(0)
let a := shl(12, shr(4, x))
let b := shl(4, shr(12, x))
let c := shr(12, shl(4, x))
let d := shr(4, shl(12, x))
let e := shl(150, shr(2, shl(150, x)))
sstore(15, x)
sstore(16, a)
sstore(17, b)
sstore(18, c)
sstore(19, d)
sstore(20, e)
}
// ====
// EVMVersion: >byzantium
// ----
// step: fullSuite
//
// {
// {
// let x := calldataload(0)
// let _1 := shl(8, x)
// let _2 := shr(8, x)
// sstore(15, x)
// sstore(16, and(_1, not(4095)))
// sstore(17, and(_2, sub(shl(248, 1), 16)))
// sstore(18, and(_2, sub(shl(244, 1), 1)))
// sstore(19, and(_1, sub(shl(252, 1), 256)))
// sstore(20, 0)
// }
// }

19
test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_unsplit.yul Normal file
View File

@ -0,0 +1,19 @@
{
let x := calldataload(0)
// This checks that the expression simplifier
// does not modify unsplit expressions.
let a := and(0xff, shr(248, shl(248, shr(248, x))))
let b := shr(12, shl(8, and(x, 0xf0f0)))
sstore(a, b)
}
// ====
// EVMVersion: >byzantium
// ----
// step: fullSuite
//
// {
// {
// let x := calldataload(0)
// sstore(shr(248, x), and(shr(4, x), 3855))
// }
// }

21
test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul Normal file
View File

@ -0,0 +1,21 @@
{
// This does not optimize the masks away. Due to the way the expression simplifier
// is built, it would have to create another `create2` opcode for the simplification
// which would be fatal.
let a := and(create2(0, 0, 0x20, 0), 0xffffffffffffffffffffffffffffffffffffffff)
let b := and(0xffffffffffffffffffffffffffffffffffffffff, create2(0, 0, 0x20, 0))
sstore(a, b)
}
// ====
// EVMVersion: >=constantinople
// ----
// step: fullSuite
//
// {
// {
// let _1 := sub(shl(160, 1), 1)
// let _2 := 0
// let a := and(create2(_2, _2, 0x20, _2), _1)
// sstore(a, and(_1, create2(_2, _2, 0x20, _2)))
// }
// }

20
test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul Normal file
View File

@ -0,0 +1,20 @@
{
// This does not optimize the masks away. Due to the way the expression simplifier
// is built, it would have to create another `create` opcode for the simplification
// which would be fatal.
let a := and(create(0, 0, 0x20), 0xffffffffffffffffffffffffffffffffffffffff)
let b := and(0xffffffffffffffffffffffffffffffffffffffff, create(0, 0, 0x20))
sstore(a, b)
}
// ====
// EVMVersion: >=istanbul
// ----
// step: fullSuite
//
// {
// {
// let _1 := sub(shl(160, 1), 1)
// let a := and(create(0, 0, 0x20), _1)
// sstore(a, and(_1, create(0, 0, 0x20)))
// }
// }