diff --git a/libevmasm/ConstantOptimiser.cpp b/libevmasm/ConstantOptimiser.cpp index 070039b1c1d4..6d71a5a18b81 100644 --- a/libevmasm/ConstantOptimiser.cpp +++ b/libevmasm/ConstantOptimiser.cpp @@ -87,10 +87,8 @@ bigint ConstantOptimisationMethod::simpleRunGas(AssemblyItems const& _items, lan gas += GasMeter::pushGas(item.data(), _evmVersion); else if (item.type() == Operation) { - if (item.instruction() == Instruction::EXP) - gas += GasCosts::expGas; - else - gas += GasMeter::runGas(item.instruction(), _evmVersion); + assertThrow(item.instruction() != Instruction::EXP, OptimizerException, "EXP used in constant optimizer."); + gas += GasMeter::runGas(item.instruction(), _evmVersion); } return gas; } @@ -246,69 +244,194 @@ AssemblyItems ComputeMethod::execute(Assembly&) const return m_routine; } -AssemblyItems ComputeMethod::findRepresentation(u256 const& _value) +AssemblyItems ComputeMethod::tryNegation(u256 const& _value, AssemblyItems const& _bestSoFar) { - if (_value < 0x10000) - // Very small value, not worth computing - return AssemblyItems{_value}; - else if (numberEncodingSize(~_value) < numberEncodingSize(_value)) - // Negated is shorter to represent - return findRepresentation(~_value) + AssemblyItems{Instruction::NOT}; - else + if (numberEncodingSize(~_value) < numberEncodingSize(_value)) { - // Decompose value into a * 2**k + b where abs(b) << 2**k - // Is not always better, try literal and decomposition method. - AssemblyItems routine{u256(_value)}; - bigint bestGas = gasNeeded(routine); - for (unsigned bits = 255; bits > 8 && m_maxSteps > 0; --bits) - { - unsigned gapDetector = unsigned((_value >> (bits - 8)) & 0x1ff); - if (gapDetector != 0xff && gapDetector != 0x100) - continue; + AssemblyItems newRoutine = findRepresentationRecursive(~_value, 256) + AssemblyItems{Instruction::NOT}; + if (gasNeeded(newRoutine) < gasNeeded(_bestSoFar)) + return newRoutine; + } + return _bestSoFar; +} - u256 powerOfTwo = u256(1) << bits; - u256 upperPart = _value >> bits; - bigint lowerPart = _value & (powerOfTwo - 1); - if ((powerOfTwo - lowerPart) < lowerPart) - { - lowerPart = lowerPart - powerOfTwo; // make it negative - upperPart++; - } - if (upperPart == 0) - continue; - if (abs(lowerPart) >= (powerOfTwo >> 8)) - continue; +// finds patterns like 000....001111 (a bunch of 1's in the least significant part) +AssemblyItems ComputeMethod::tryNotZeroShiftRight(u256 const& _value, AssemblyItems const& _bestSoFar) +{ + unsigned onesAtEnd = 0; + while (((_value >> onesAtEnd) & 1) == 1 && onesAtEnd < 256) + ++onesAtEnd; - AssemblyItems newRoutine; - if (lowerPart != 0) - newRoutine += findRepresentation(u256(abs(lowerPart))); - if (m_params.evmVersion.hasBitwiseShifting()) - { - newRoutine += findRepresentation(upperPart); - newRoutine += AssemblyItems{u256(bits), Instruction::SHL}; - } - else - { - newRoutine += AssemblyItems{u256(bits), u256(2), Instruction::EXP}; - if (upperPart != 1) - newRoutine += findRepresentation(upperPart) + AssemblyItems{Instruction::MUL}; - } - if (lowerPart > 0) - newRoutine += AssemblyItems{Instruction::ADD}; - else if (lowerPart < 0) - newRoutine.push_back(Instruction::SUB); + if ((_value >> onesAtEnd) == 0) // implicitly checks that onesAtEnd > 0 + { + AssemblyItems newRoutine = AssemblyItems{u256(0), Instruction::NOT}; + newRoutine += AssemblyItems{u256(256 - onesAtEnd), Instruction::SHR}; + if (gasNeeded(newRoutine) < gasNeeded(_bestSoFar)) + return newRoutine; + } + return _bestSoFar; +} + +// finds patterns like 1111.....00000 (a bunch of 1's in the most significant part) +AssemblyItems ComputeMethod::tryNotZeroShiftLeft(u256 const& _value, AssemblyItems const& _bestSoFar) +{ + unsigned onesAtStart = 0; + while (onesAtStart < 256 && ((_value >> (255 - onesAtStart)) & 1) == 1) + ++onesAtStart; + + if ((_value << onesAtStart) == 0) // implicitly checks that onesAtStart > 0 + { + AssemblyItems newRoutine = AssemblyItems{u256(0), Instruction::NOT}; + newRoutine += AssemblyItems{u256(256 - onesAtStart), Instruction::SHL}; + if (gasNeeded(newRoutine) < gasNeeded(_bestSoFar)) + return newRoutine; + } + return _bestSoFar; +} - if (m_maxSteps > 0) - m_maxSteps--; +// finds patterns like xxxx00000 (a bunch of 0's in the least significant part) +AssemblyItems ComputeMethod::tryLeftShift(u256 const& _value, AssemblyItems const& _bestSoFar, unsigned targetBits) +{ + unsigned zerosAtEnd = 0; + while (((_value >> zerosAtEnd) & 1) == 0 && zerosAtEnd < 256) + ++zerosAtEnd; + + if (zerosAtEnd >= 16) + { + AssemblyItems newRoutine = findRepresentationRecursive(_value >> zerosAtEnd, targetBits - zerosAtEnd); + newRoutine += AssemblyItems{u256(zerosAtEnd), Instruction::SHL}; + if (gasNeeded(newRoutine) < gasNeeded(_bestSoFar)) + return newRoutine; + } + return _bestSoFar; +} + +// decomposes the constant into a | b at byte boundaries, works well when either side can be represented easily +// example: 0x2300000000000017 +// note: addition doesn't work better than OR and is conceptually more difficult (overflow, carry, etc) +// large example with OR: +// value = fffffffffffffffffffffffdffffffff0000000000000000ffffffffffffffff +// repr = PUSH 1 PUSH 61 SHL PUSH 0 NOT PUSH c0 SHR OR PUSH 40 SHL NOT +AssemblyItems ComputeMethod::tryAorB(u256 const& _value, AssemblyItems const& _bestSoFar, unsigned targetBits) +{ + // don't recurse too much + if (m_recursionDepth >= 2) + return _bestSoFar; + m_recursionDepth++; + AssemblyItems routine = _bestSoFar; + bigint bestGas = gasNeeded(routine); + bigint upperBareMinGas = gasNeeded(AssemblyItems{u256(1)} + AssemblyItems{u256(2)} + AssemblyItems{Instruction::SHL}); + for (unsigned bits = 8; bits < targetBits; bits += 8) + { + u256 powerOfTwo = u256(1) << bits; + u256 upperPart = (_value >> bits) << bits; + if (upperPart == 0) + break; + u256 lowerPart = _value & (powerOfTwo - 1); + if (lowerPart != 0) + { + AssemblyItems lowerRep = findRepresentationRecursive(lowerPart, bits); + // try an early exit with a mock upper part -- makes a huge speed difference + if (gasNeeded(lowerRep) + upperBareMinGas >= gasNeeded(routine)) // it'll never get better, because lower gets more and more complex + break; + AssemblyItems newRoutine = findRepresentationRecursive(upperPart, targetBits) + lowerRep + AssemblyItems{Instruction::OR}; bigint newGas = gasNeeded(newRoutine); if (newGas < bestGas) { - bestGas = std::move(newGas); - routine = std::move(newRoutine); + routine = newRoutine; + bestGas = newGas; + } + } + } + m_recursionDepth--; + return routine; +} + +// subtraction can cause a lot of bit flips +// bits that are set cost more to represent, so setting them cheaply is the goal here +// looks for byte wise subtractions that cause a bit flip in the next byte. +// 0x12FFFF76 => what do we need to add to 0x76 to flip the next highest bit? 0x100 - 0x76 = 0x8A +// 0x12FFFF76 = 0x13000000 - 0x8A +// note: addition doesn't work much better than OR, which is tried above +// very few real-world bit patterns are optimal with SUB +// large example: +// value = 3fffffffffffffffc0 repr = PUSH 40 PUSH 1 PUSH 46 SHL SUB +// just beats out PUSH0 NOT PUSH R SHR PUSH L SHL -- same number of bytes, more gas with ~0 +AssemblyItems ComputeMethod::trySub(u256 const& _value, AssemblyItems const& _bestSoFar, unsigned targetBits) +{ + // don't recurse too much + if (m_recursionDepth >= 2) + return _bestSoFar; + m_recursionDepth++; + AssemblyItems routine = _bestSoFar; + u256 lastRhs = 0; + for (unsigned bits = 8; bits < 32; bits += 8) //higher bits don't seem to help + { + u256 powerOfTwo = u256(1) << bits; + u256 lowerPart = _value & (powerOfTwo - 1); + if (lowerPart != 0) + { + u256 rhs = powerOfTwo - lowerPart; + if (rhs > _value) + break; + if (lastRhs != rhs) { // don't try the same routine again + u256 lhs = _value + rhs; // we want _value = lhs - rhs + lastRhs = rhs; + AssemblyItems newRoutine = findRepresentationRecursive(rhs, bits) + findRepresentationRecursive(lhs, targetBits + 1) + AssemblyItems{Instruction::SUB}; + if (gasNeeded(newRoutine) < gasNeeded(routine)) + routine = newRoutine; } } + } + m_recursionDepth--; + return routine; +} + +AssemblyItems ComputeMethod::findRepresentation(u256 const& _value) +{ + AssemblyItems routine = AssemblyItems{_value}; + if (_value < 0x100000000) + // Very small value, always optimal as is; empirically, even at optimize-runs 1, no computation is better + // 0x100000000 is the first small number that has a "better" representation than PUSH5: PUSH1 0x1 PUSH1 0x20 SHL + // "better" only for low runs + return routine; + + return findRepresentationRecursive(_value, 256); +} + +AssemblyItems ComputeMethod::findRepresentationRecursive(u256 const& _value, unsigned targetBits) +{ + AssemblyItems routine = AssemblyItems{_value}; + if (_value < 0x100000000) + // Very small value, always optimal as is; empirically, even at optimize-runs 1, no computation is better + // 0x100000000 is the first small number that has a "better" representation than PUSH5: PUSH1 0x1 PUSH1 0x20 SHL + // "better" only for low runs return routine; + + // filter out numbers with random bit patterns. we want at least 32 contiguous zeros or ones + u256 mask32bit = (u256(1) << 32) - 1; + bool found = _value < (u256(1) << (targetBits - 32)); // if upper bits are zero, it'll pass the loop test + for(unsigned i = 0; i < (targetBits - 32) && !found; i++) + { + u256 chunk = (_value >> i) & mask32bit; + found = chunk == 0 || chunk == mask32bit; } + if (!found) + return routine; + + if (targetBits >= 256) + routine = tryNegation(_value, std::move(routine)); + + if (m_params.evmVersion.hasBitwiseShifting()) + { + routine = tryLeftShift(_value, routine, targetBits); + routine = tryNotZeroShiftRight(_value, routine); + if (targetBits >= 256) + routine = tryNotZeroShiftLeft(_value, std::move(routine)); + } + routine = tryAorB(_value, routine, targetBits); + routine = trySub(_value, routine, targetBits); + return routine; } bool ComputeMethod::checkRepresentation(u256 const& _value, AssemblyItems const& _routine) const @@ -340,6 +463,9 @@ bool ComputeMethod::checkRepresentation(u256 const& _value, AssemblyItems const& case Instruction::SUB: sp[-1] = sp[0] - sp[-1]; break; + case Instruction::OR: + sp[-1] = sp[0] | sp[-1]; + break; case Instruction::NOT: sp[0] = ~sp[0]; break; @@ -379,9 +505,8 @@ bool ComputeMethod::checkRepresentation(u256 const& _value, AssemblyItems const& bigint ComputeMethod::gasNeeded(AssemblyItems const& _routine) const { - auto numExps = static_cast(count(_routine.begin(), _routine.end(), Instruction::EXP)); return combineGas( - simpleRunGas(_routine, m_params.evmVersion) + numExps * (GasCosts::expGas + GasCosts::expByteGas(m_params.evmVersion)), + simpleRunGas(_routine, m_params.evmVersion), // Data gas for routine: Some bytes are zero, but we ignore them. bytesRequired(_routine, m_params.evmVersion) * (m_params.isCreation ? GasCosts::txDataNonZeroGas(m_params.evmVersion) : GasCosts::createDataGas), 0 diff --git a/libevmasm/ConstantOptimiser.h b/libevmasm/ConstantOptimiser.h index 3848b153146c..7c9b0b54d2de 100644 --- a/libevmasm/ConstantOptimiser.h +++ b/libevmasm/ConstantOptimiser.h @@ -141,13 +141,19 @@ class ComputeMethod: public ConstantOptimisationMethod protected: /// Tries to recursively find a way to compute @a _value. AssemblyItems findRepresentation(u256 const& _value); + AssemblyItems findRepresentationRecursive(u256 const& _value, unsigned targetBits); + AssemblyItems tryNegation(u256 const& _value, AssemblyItems const& _bestSoFar); + AssemblyItems tryNotZeroShiftRight(u256 const& _value, AssemblyItems const& _bestSoFar); + AssemblyItems tryNotZeroShiftLeft(u256 const& _value, AssemblyItems const& _bestSoFar); + AssemblyItems tryLeftShift(u256 const& _value, AssemblyItems const& _bestSoFar, unsigned targetBits); + AssemblyItems tryAorB(u256 const& _value, AssemblyItems const& _bestSoFar, unsigned targetBits); + AssemblyItems trySub(u256 const& _value, AssemblyItems const& _bestSoFar, unsigned targetBits); /// Recomputes the value from the calculated representation and checks for correctness. bool checkRepresentation(u256 const& _value, AssemblyItems const& _routine) const; bigint gasNeeded(AssemblyItems const& _routine) const; - /// Counter for the complexity of optimization, will stop when it reaches zero. - size_t m_maxSteps = 10000; AssemblyItems m_routine; + unsigned m_recursionDepth = 0; }; } diff --git a/libyul/backends/evm/ConstantOptimiser.cpp b/libyul/backends/evm/ConstantOptimiser.cpp index aa744415bf9d..72c34b21a3c5 100644 --- a/libyul/backends/evm/ConstantOptimiser.cpp +++ b/libyul/backends/evm/ConstantOptimiser.cpp @@ -54,16 +54,10 @@ struct MiniEVMInterpreter args.emplace_back(eval(arg)); switch (_instr) { - case evmasm::Instruction::ADD: - return args.at(0) + args.at(1); - case evmasm::Instruction::SUB: - return args.at(0) - args.at(1); - case evmasm::Instruction::MUL: - return args.at(0) * args.at(1); - case evmasm::Instruction::EXP: - return exp256(args.at(0), args.at(1)); case evmasm::Instruction::SHL: return args.at(0) > 255 ? 0 : (args.at(1) << unsigned(args.at(0))); + case evmasm::Instruction::SHR: + return args.at(1) >> unsigned(args.at(0)); case evmasm::Instruction::NOT: return ~args.at(0); default: @@ -97,6 +91,8 @@ void ConstantOptimiser::visit(Expression& _e) if (literal.kind != LiteralKind::Number) return; + yulAssert(m_dialect.auxiliaryBuiltinHandles().not_); + if ( Expression const* repr = RepresentationFinder(m_dialect, m_meter, debugDataOf(_e), m_cache) @@ -110,7 +106,7 @@ void ConstantOptimiser::visit(Expression& _e) Expression const* RepresentationFinder::tryFindRepresentation(u256 const& _value) { - if (_value < 0x10000) + if (_value < 0x100000000) return nullptr; Representation const& repr = findRepresentation(_value); @@ -122,64 +118,44 @@ Expression const* RepresentationFinder::tryFindRepresentation(u256 const& _value Representation const& RepresentationFinder::findRepresentation(u256 const& _value) { + // since findRepresentation is called recursively, the small value check must be done here + if (_value < 0x100000000) + return m_cache[_value] = represent(_value); + if (m_cache.count(_value)) return m_cache.at(_value); - yulAssert(m_dialect.auxiliaryBuiltinHandles().not_); - yulAssert(m_dialect.auxiliaryBuiltinHandles().exp); - yulAssert(m_dialect.auxiliaryBuiltinHandles().mul); - yulAssert(m_dialect.auxiliaryBuiltinHandles().add); - yulAssert(m_dialect.auxiliaryBuiltinHandles().sub); - auto const& auxHandles = m_dialect.auxiliaryBuiltinHandles(); Representation routine = represent(_value); - if (numberEncodingSize(~_value) < numberEncodingSize(_value)) - // Negated is shorter to represent - routine = min(std::move(routine), represent(*auxHandles.not_, findRepresentation(~_value))); - - // Decompose value into a * 2**k + b where abs(b) << 2**k - for (unsigned bits = 255; bits > 8 && m_maxSteps > 0; --bits) + if (m_dialect.evmVersion().hasBitwiseShifting()) { - unsigned gapDetector = unsigned((_value >> (bits - 8)) & 0x1ff); - if (gapDetector != 0xff && gapDetector != 0x100) - continue; - - u256 powerOfTwo = u256(1) << bits; - u256 upperPart = _value >> bits; - bigint lowerPart = _value & (powerOfTwo - 1); - if ((powerOfTwo - lowerPart) < lowerPart) + // try left shift for patterns like xxxx0000 + unsigned zerosAtEnd = 0; + while (((_value >> zerosAtEnd) & 1) == 0 && zerosAtEnd < 256) + ++zerosAtEnd; + if (zerosAtEnd > 0) { - lowerPart = lowerPart - powerOfTwo; // make it negative - upperPart++; + Representation newRoutine = represent(*auxHandles.shl, represent(zerosAtEnd), findRepresentation(_value >> zerosAtEnd)); + routine = min(std::move(routine), std::move(newRoutine)); } - if (upperPart == 0) - continue; - if (abs(lowerPart) >= (powerOfTwo >> 8)) - continue; - Representation newRoutine; - if (m_dialect.evmVersion().hasBitwiseShifting()) - newRoutine = represent(*auxHandles.shl, represent(bits), findRepresentation(upperPart)); - else + // try notZeroShift for patterns 0000....0011111 + unsigned onesAtEnd = 0; + while (((_value >> onesAtEnd) & 1) == 1 && onesAtEnd < 256) + ++onesAtEnd; + + if ((_value >> onesAtEnd) == 0) // implicitly checks that onesAtEnd > 0 { - newRoutine = represent(*auxHandles.exp, represent(2), represent(bits)); - if (upperPart != 1) - newRoutine = represent(*auxHandles.mul, findRepresentation(upperPart), newRoutine); + Representation newRoutine = represent(*auxHandles.shr, represent(256 - onesAtEnd), represent(*auxHandles.not_, represent(0))); + routine = min(std::move(routine), std::move(newRoutine)); } + } - if (newRoutine.cost >= routine.cost) - continue; - - if (lowerPart > 0) - newRoutine = represent(*auxHandles.add, newRoutine, findRepresentation(u256(abs(lowerPart)))); - else if (lowerPart < 0) - newRoutine = represent(*auxHandles.sub, newRoutine, findRepresentation(u256(abs(lowerPart)))); + // try NOT + if (numberEncodingSize(~_value) < numberEncodingSize(_value)) + routine = min(std::move(routine), represent(*auxHandles.not_, findRepresentation(~_value))); - if (m_maxSteps > 0) - m_maxSteps--; - routine = min(std::move(routine), std::move(newRoutine)); - } yulAssert(MiniEVMInterpreter{m_dialect}.eval(*routine.expression) == _value, "Invalid expression generated."); return m_cache[_value] = std::move(routine); } diff --git a/libyul/backends/evm/ConstantOptimiser.h b/libyul/backends/evm/ConstantOptimiser.h index 9c25450bf96f..0442abd6aae7 100644 --- a/libyul/backends/evm/ConstantOptimiser.h +++ b/libyul/backends/evm/ConstantOptimiser.h @@ -101,8 +101,6 @@ class RepresentationFinder EVMDialect const& m_dialect; GasMeter const& m_meter; langutil::DebugData::ConstPtr m_debugData; - /// Counter for the complexity of optimization, will stop when it reaches zero. - size_t m_maxSteps = 10000; std::map& m_cache; }; diff --git a/libyul/backends/evm/EVMDialect.cpp b/libyul/backends/evm/EVMDialect.cpp index 61ee043352f4..229f49b991ae 100644 --- a/libyul/backends/evm/EVMDialect.cpp +++ b/libyul/backends/evm/EVMDialect.cpp @@ -232,12 +232,9 @@ EVMDialect::EVMDialect(langutil::EVMVersion _evmVersion, bool _objectAccess): m_storageLoadFunction = EVMDialect::findBuiltin("sload"); m_hashFunction = EVMDialect::findBuiltin("keccak256"); - m_auxiliaryBuiltinHandles.add = EVMDialect::findBuiltin("add"); - m_auxiliaryBuiltinHandles.exp = EVMDialect::findBuiltin("exp"); - m_auxiliaryBuiltinHandles.mul = EVMDialect::findBuiltin("mul"); m_auxiliaryBuiltinHandles.not_ = EVMDialect::findBuiltin("not"); m_auxiliaryBuiltinHandles.shl = EVMDialect::findBuiltin("shl"); - m_auxiliaryBuiltinHandles.sub = EVMDialect::findBuiltin("sub"); + m_auxiliaryBuiltinHandles.shr = EVMDialect::findBuiltin("shr"); } std::optional EVMDialect::findBuiltin(std::string_view _name) const diff --git a/libyul/backends/evm/EVMDialect.h b/libyul/backends/evm/EVMDialect.h index 52508ddd1f70..19c711e33923 100644 --- a/libyul/backends/evm/EVMDialect.h +++ b/libyul/backends/evm/EVMDialect.h @@ -58,12 +58,9 @@ class EVMDialect: public Dialect /// e.g., certain optimization steps. struct AuxiliaryBuiltinHandles { - std::optional add; - std::optional exp; - std::optional mul; std::optional not_; std::optional shl; - std::optional sub; + std::optional shr; }; /// Constructor, should only be used internally. Use the factory functions below. EVMDialect(langutil::EVMVersion _evmVersion, bool _objectAccess); diff --git a/test/cmdlineTests/ir_subobject_order/output b/test/cmdlineTests/ir_subobject_order/output index d41b65bf9a62..4d941fc35529 100644 --- a/test/cmdlineTests/ir_subobject_order/output +++ b/test/cmdlineTests/ir_subobject_order/output @@ -30,7 +30,7 @@ object "C_33" { if callvalue() { revert(0, 0) } let _2 := datasize("A_13") let _3 := add(_1, _2) - if or(gt(_3, sub(shl(64, 1), 1)), lt(_3, _1)) + if or(gt(_3, shr(192, not(0))), lt(_3, _1)) { mstore(0, shl(224, 0x4e487b71)) mstore(4, 0x41) @@ -44,11 +44,11 @@ object "C_33" { returndatacopy(pos, 0, returndatasize()) revert(pos, returndatasize()) } - sstore(0, or(and(sload(0), not(sub(shl(160, 1), 1))), and(expr_address, sub(shl(160, 1), 1)))) + sstore(0, or(and(sload(0), not(shr(96, not(0)))), and(expr_address, shr(96, not(0))))) let _4 := mload(64) let _5 := datasize("B_7") let _6 := add(_4, _5) - if or(gt(_6, sub(shl(64, 1), 1)), lt(_6, _4)) + if or(gt(_6, shr(192, not(0))), lt(_6, _4)) { mstore(0, shl(224, 0x4e487b71)) mstore(4, 0x41) @@ -62,7 +62,7 @@ object "C_33" { returndatacopy(pos_1, 0, returndatasize()) revert(pos_1, returndatasize()) } - sstore(0x01, or(and(sload(0x01), not(sub(shl(160, 1), 1))), and(expr_address_1, sub(shl(160, 1), 1)))) + sstore(0x01, or(and(sload(0x01), not(shr(96, not(0)))), and(expr_address_1, shr(96, not(0))))) let _7 := mload(64) let _8 := datasize("C_33_deployed") codecopy(_7, dataoffset("C_33_deployed"), _8) diff --git a/test/cmdlineTests/optimizer_BlockDeDuplicator/output b/test/cmdlineTests/optimizer_BlockDeDuplicator/output index b3a645be3569..8bb023a12fc3 100644 --- a/test/cmdlineTests/optimizer_BlockDeDuplicator/output +++ b/test/cmdlineTests/optimizer_BlockDeDuplicator/output @@ -7,11 +7,11 @@ EVM assembly: 0x00 dup1 sload - not(sub(shl(0x40, 0x01), 0x01)) + shl(0x40, not(0x00)) and /* "input.sol":201:206 fun_x */ or(tag_0_7, shl(0x20, tag_2)) - sub(shl(0x40, 0x01), 0x01) + shr(0xc0, not(0x00)) /* "input.sol":179:210 function() r = true ? fun_x : f */ and or diff --git a/test/cmdlineTests/optimizer_inliner_dynamic_reference_constructor/output b/test/cmdlineTests/optimizer_inliner_dynamic_reference_constructor/output index 5997bd1c7b60..3be86be8c823 100644 --- a/test/cmdlineTests/optimizer_inliner_dynamic_reference_constructor/output +++ b/test/cmdlineTests/optimizer_inliner_dynamic_reference_constructor/output @@ -17,11 +17,11 @@ tag_1: /* "input.sol":93:98 x = f */ dup1 sload - not(sub(shl(0x40, 0x01), 0x01)) + shl(0x40, not(0x00)) and /* "input.sol":97:98 f */ or(tag_0_12, shl(0x20, tag_4)) - sub(shl(0x40, 0x01), 0x01) + shr(0xc0, not(0x00)) /* "input.sol":93:98 x = f */ and or diff --git a/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json b/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json index 4ef3c6df1873..19c41d97fc0a 100644 --- a/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json +++ b/test/cmdlineTests/standard_debug_info_in_evm_asm_via_ir_location/output.json @@ -20,7 +20,7 @@ dup4 add swap2 - sub(shl(0x40, 0x01), 0x01) + shr(0xc0, not(0x00)) dup4 gt dup5 @@ -104,7 +104,7 @@ sub_0: assembly { jumpi(tag_26, callvalue) jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00)) sload(0x00) - sub(shl(0xff, 0x01), 0x01) + shr(0x01, not(0x00)) dup2 eq tag_14 @@ -350,7 +350,7 @@ sub_0: assembly { dup4 add swap2 - sub(shl(0x40, 0x01), 0x01) + shr(0xc0, not(0x00)) dup4 gt dup5 @@ -450,7 +450,7 @@ sub_0: assembly { jumpi(tag_26, callvalue) jumpi(tag_26, slt(add(not(0x03), calldatasize), 0x00)) sload(0x00) - sub(shl(0xff, 0x01), 0x01) + shr(0x01, not(0x00)) dup2 eq tag_14 diff --git a/test/cmdlineTests/standard_debug_info_in_yul_location/output.json b/test/cmdlineTests/standard_debug_info_in_yul_location/output.json index 5ff4e7a190fc..96e29bb0fba9 100644 --- a/test/cmdlineTests/standard_debug_info_in_yul_location/output.json +++ b/test/cmdlineTests/standard_debug_info_in_yul_location/output.json @@ -619,7 +619,7 @@ object \"C_54\" { let programSize := datasize(\"C_54\") let argSize := sub(codesize(), programSize) let newFreePtr := add(_1, and(add(argSize, 31), not(31))) - if or(gt(newFreePtr, sub(shl(64, 1), 1)), lt(newFreePtr, _1)) + if or(gt(newFreePtr, shr(192, not(0))), lt(newFreePtr, _1)) { mstore(/** @src -1:-1:-1 */ 0, /** @src 0:79:510 \"contract C...\" */ shl(224, 0x4e487b71)) mstore(4, 0x41) @@ -684,7 +684,7 @@ object \"C_54\" { if callvalue() { revert(0, 0) } if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) } let _3 := sload(0) - if eq(_3, sub(shl(255, 1), 1)) + if eq(_3, shr(1, not(0))) { mstore(0, shl(224, 0x4e487b71)) mstore(4, 0x11) @@ -1455,7 +1455,7 @@ object \"D_72\" { let programSize := datasize(\"D_72\") let argSize := sub(codesize(), programSize) let newFreePtr := add(_1, and(add(argSize, 31), not(31))) - if or(gt(newFreePtr, sub(shl(64, 1), 1)), lt(newFreePtr, _1)) + if or(gt(newFreePtr, shr(192, not(0))), lt(newFreePtr, _1)) { mstore(/** @src -1:-1:-1 */ 0, /** @src 1:91:181 \"contract D is C(3)...\" */ shl(224, 0x4e487b71)) mstore(4, 0x41) @@ -1527,7 +1527,7 @@ object \"D_72\" { if callvalue() { revert(0, 0) } if slt(add(calldatasize(), not(3)), 0) { revert(0, 0) } let _3 := sload(0) - if eq(_3, sub(shl(255, 1), 1)) + if eq(_3, shr(1, not(0))) { mstore(0, shl(224, 0x4e487b71)) mstore(4, 0x11) diff --git a/test/cmdlineTests/standard_yul_cfg_json_export/output.json b/test/cmdlineTests/standard_yul_cfg_json_export/output.json index 3b370e250149..0395b82b21e1 100644 --- a/test/cmdlineTests/standard_yul_cfg_json_export/output.json +++ b/test/cmdlineTests/standard_yul_cfg_json_export/output.json @@ -1041,7 +1041,7 @@ }, { "exit": { - "cond": "v85", + "cond": "v84", "targets": [ "Block18", "Block17" @@ -1079,45 +1079,44 @@ }, { "in": [ - "0xa0", - "0x01" + "0x00" ], - "op": "shl", + "op": "not", "out": [ - "v76" + "v74" ] }, { "in": [ - "v76", - "0x01" + "0x60", + "v74" ], - "op": "sub", + "op": "shr", "out": [ - "v77" + "v76" ] }, { "in": [ "v60", - "v77" + "v76" ], "op": "and", "out": [ - "v82" + "v81" ] }, { "in": [], "op": "gas", "out": [ - "v83" + "v82" ] }, { "in": [ - "v83", "v82", + "v81", "v68", "0x04", "v68", @@ -1125,16 +1124,16 @@ ], "op": "staticcall", "out": [ - "v84" + "v83" ] }, { "in": [ - "v84" + "v83" ], "op": "iszero", "out": [ - "v85" + "v84" ] } ], @@ -1144,7 +1143,7 @@ ], "out": [ "v68", - "v84" + "v83" ] }, "type": "BuiltinCall" @@ -1204,7 +1203,7 @@ }, { "exit": { - "cond": "v84", + "cond": "v83", "targets": [ "Block21", "Block20" @@ -1216,7 +1215,7 @@ "liveness": { "in": [ "v68", - "v84" + "v83" ], "out": [ "v68" @@ -1235,21 +1234,21 @@ ], "op": "mload", "out": [ - "v86" + "v85" ] }, { "in": [], "op": "returndatasize", "out": [ - "v87" + "v86" ] }, { "in": [ - "v86", + "v85", "0x00", - "v87" + "v86" ], "op": "returndatacopy", "out": [] @@ -1258,13 +1257,13 @@ "in": [], "op": "returndatasize", "out": [ - "v89" + "v88" ] }, { "in": [ - "v86", - "v89" + "v85", + "v88" ], "op": "revert", "out": [] @@ -1289,11 +1288,11 @@ { "in": [ "0x00", - "v144" + "v143" ], "op": "PhiFunction", "out": [ - "phi146" + "phi145" ] }, { @@ -1302,20 +1301,20 @@ ], "op": "mload", "out": [ - "v145" + "v144" ] }, { "in": [ - "v145", - "phi146" + "v144", + "phi145" ], "op": "mstore", "out": [] }, { "in": [ - "v145", + "v144", "0x20" ], "op": "return", @@ -1324,7 +1323,7 @@ ], "liveness": { "in": [ - "phi146" + "phi145" ], "out": [] }, @@ -1332,7 +1331,7 @@ }, { "exit": { - "cond": "v97", + "cond": "v96", "targets": [ "Block23", "Block22" @@ -1345,17 +1344,17 @@ "in": [], "op": "returndatasize", "out": [ - "v96" + "v95" ] }, { "in": [ "0x20", - "v96" + "v95" ], "op": "gt", "out": [ - "v97" + "v96" ] } ], @@ -1375,7 +1374,7 @@ "Block22" ], "exit": { - "cond": "v116", + "cond": "v115", "targets": [ "Block25", "Block24" @@ -1387,11 +1386,11 @@ { "in": [ "0x20", - "v98" + "v97" ], "op": "PhiFunction", "out": [ - "phi101" + "phi100" ] }, { @@ -1400,79 +1399,79 @@ ], "op": "not", "out": [ - "v100" + "v99" ] }, { "in": [ - "phi101", + "phi100", "0x1f" ], "op": "add", "out": [ - "v104" + "v103" ] }, { "in": [ - "v104", - "v100" + "v103", + "v99" ], "op": "and", "out": [ - "v105" + "v104" ] }, { "in": [ "v68", - "v105" + "v104" ], "op": "add", "out": [ - "v113" + "v112" ] }, { "in": [ - "v113", + "v112", "v68" ], "op": "lt", "out": [ - "v114" + "v113" ] }, { "in": [ - "v113", + "v112", "0xffffffffffffffff" ], "op": "gt", "out": [ - "v115" + "v114" ] }, { "in": [ - "v115", - "v114" + "v114", + "v113" ], "op": "or", "out": [ - "v116" + "v115" ] } ], "liveness": { "in": [ "v68", - "phi101" + "phi100" ], "out": [ "v68", - "phi101", - "v113" + "phi100", + "v112" ] }, "type": "BuiltinCall" @@ -1490,7 +1489,7 @@ "in": [], "op": "returndatasize", "out": [ - "v98" + "v97" ] } ], @@ -1499,7 +1498,7 @@ "v68" ], "out": [ - "v98", + "v97", "v68" ] }, @@ -1507,7 +1506,7 @@ }, { "exit": { - "cond": "v137", + "cond": "v136", "targets": [ "Block28", "Block27" @@ -1519,7 +1518,7 @@ { "in": [ "0x40", - "v113" + "v112" ], "op": "mstore", "out": [] @@ -1527,39 +1526,39 @@ { "in": [ "v68", - "phi101" + "phi100" ], "op": "add", "out": [ - "v135" + "v134" ] }, { "in": [ - "v135", + "v134", "v68" ], "op": "sub", "out": [ - "v136" + "v135" ] }, { "in": [ - "v136", + "v135", "0x20" ], "op": "slt", "out": [ - "v137" + "v136" ] } ], "liveness": { "in": [ "v68", - "phi101", - "v113" + "phi100", + "v112" ], "out": [ "v68" @@ -1580,13 +1579,13 @@ ], "op": "shl", "out": [ - "v117" + "v116" ] }, { "in": [ "0x00", - "v117" + "v116" ], "op": "mstore", "out": [] @@ -1629,7 +1628,7 @@ ], "op": "mload", "out": [ - "v144" + "v143" ] } ], @@ -1638,7 +1637,7 @@ "v68" ], "out": [ - "v144" + "v143" ] }, "type": "BuiltinCall" diff --git a/test/cmdlineTests/viair_subobject_optimization/output b/test/cmdlineTests/viair_subobject_optimization/output index 523cff79e0fa..a17f65e751f8 100644 --- a/test/cmdlineTests/viair_subobject_optimization/output +++ b/test/cmdlineTests/viair_subobject_optimization/output @@ -18,7 +18,7 @@ EVM assembly: dup4 add swap2 - sub(shl(0x40, 0x01), 0x01) + shr(0xc0, not(0x00)) dup4 gt dup5 @@ -223,7 +223,7 @@ sub_0: assembly { dup4 add swap2 - sub(shl(0x40, 0x01), 0x01) + shr(0xc0, not(0x00)) dup4 gt dup5 diff --git a/test/cmdlineTests/yul_cfg_json_export/output b/test/cmdlineTests/yul_cfg_json_export/output index 1d67e5272fde..d04c99a038b4 100644 --- a/test/cmdlineTests/yul_cfg_json_export/output +++ b/test/cmdlineTests/yul_cfg_json_export/output @@ -1041,7 +1041,7 @@ Yul Control Flow Graph: }, { "exit": { - "cond": "v85", + "cond": "v84", "targets": [ "Block18", "Block17" @@ -1079,45 +1079,44 @@ Yul Control Flow Graph: }, { "in": [ - "0xa0", - "0x01" + "0x00" ], - "op": "shl", + "op": "not", "out": [ - "v76" + "v74" ] }, { "in": [ - "v76", - "0x01" + "0x60", + "v74" ], - "op": "sub", + "op": "shr", "out": [ - "v77" + "v76" ] }, { "in": [ "v60", - "v77" + "v76" ], "op": "and", "out": [ - "v82" + "v81" ] }, { "in": [], "op": "gas", "out": [ - "v83" + "v82" ] }, { "in": [ - "v83", "v82", + "v81", "v68", "0x04", "v68", @@ -1125,16 +1124,16 @@ Yul Control Flow Graph: ], "op": "staticcall", "out": [ - "v84" + "v83" ] }, { "in": [ - "v84" + "v83" ], "op": "iszero", "out": [ - "v85" + "v84" ] } ], @@ -1144,7 +1143,7 @@ Yul Control Flow Graph: ], "out": [ "v68", - "v84" + "v83" ] }, "type": "BuiltinCall" @@ -1204,7 +1203,7 @@ Yul Control Flow Graph: }, { "exit": { - "cond": "v84", + "cond": "v83", "targets": [ "Block21", "Block20" @@ -1216,7 +1215,7 @@ Yul Control Flow Graph: "liveness": { "in": [ "v68", - "v84" + "v83" ], "out": [ "v68" @@ -1235,21 +1234,21 @@ Yul Control Flow Graph: ], "op": "mload", "out": [ - "v86" + "v85" ] }, { "in": [], "op": "returndatasize", "out": [ - "v87" + "v86" ] }, { "in": [ - "v86", + "v85", "0x00", - "v87" + "v86" ], "op": "returndatacopy", "out": [] @@ -1258,13 +1257,13 @@ Yul Control Flow Graph: "in": [], "op": "returndatasize", "out": [ - "v89" + "v88" ] }, { "in": [ - "v86", - "v89" + "v85", + "v88" ], "op": "revert", "out": [] @@ -1289,11 +1288,11 @@ Yul Control Flow Graph: { "in": [ "0x00", - "v144" + "v143" ], "op": "PhiFunction", "out": [ - "phi146" + "phi145" ] }, { @@ -1302,20 +1301,20 @@ Yul Control Flow Graph: ], "op": "mload", "out": [ - "v145" + "v144" ] }, { "in": [ - "v145", - "phi146" + "v144", + "phi145" ], "op": "mstore", "out": [] }, { "in": [ - "v145", + "v144", "0x20" ], "op": "return", @@ -1324,7 +1323,7 @@ Yul Control Flow Graph: ], "liveness": { "in": [ - "phi146" + "phi145" ], "out": [] }, @@ -1332,7 +1331,7 @@ Yul Control Flow Graph: }, { "exit": { - "cond": "v97", + "cond": "v96", "targets": [ "Block23", "Block22" @@ -1345,17 +1344,17 @@ Yul Control Flow Graph: "in": [], "op": "returndatasize", "out": [ - "v96" + "v95" ] }, { "in": [ "0x20", - "v96" + "v95" ], "op": "gt", "out": [ - "v97" + "v96" ] } ], @@ -1375,7 +1374,7 @@ Yul Control Flow Graph: "Block22" ], "exit": { - "cond": "v116", + "cond": "v115", "targets": [ "Block25", "Block24" @@ -1387,11 +1386,11 @@ Yul Control Flow Graph: { "in": [ "0x20", - "v98" + "v97" ], "op": "PhiFunction", "out": [ - "phi101" + "phi100" ] }, { @@ -1400,79 +1399,79 @@ Yul Control Flow Graph: ], "op": "not", "out": [ - "v100" + "v99" ] }, { "in": [ - "phi101", + "phi100", "0x1f" ], "op": "add", "out": [ - "v104" + "v103" ] }, { "in": [ - "v104", - "v100" + "v103", + "v99" ], "op": "and", "out": [ - "v105" + "v104" ] }, { "in": [ "v68", - "v105" + "v104" ], "op": "add", "out": [ - "v113" + "v112" ] }, { "in": [ - "v113", + "v112", "v68" ], "op": "lt", "out": [ - "v114" + "v113" ] }, { "in": [ - "v113", + "v112", "0xffffffffffffffff" ], "op": "gt", "out": [ - "v115" + "v114" ] }, { "in": [ - "v115", - "v114" + "v114", + "v113" ], "op": "or", "out": [ - "v116" + "v115" ] } ], "liveness": { "in": [ "v68", - "phi101" + "phi100" ], "out": [ "v68", - "phi101", - "v113" + "phi100", + "v112" ] }, "type": "BuiltinCall" @@ -1490,7 +1489,7 @@ Yul Control Flow Graph: "in": [], "op": "returndatasize", "out": [ - "v98" + "v97" ] } ], @@ -1499,7 +1498,7 @@ Yul Control Flow Graph: "v68" ], "out": [ - "v98", + "v97", "v68" ] }, @@ -1507,7 +1506,7 @@ Yul Control Flow Graph: }, { "exit": { - "cond": "v137", + "cond": "v136", "targets": [ "Block28", "Block27" @@ -1519,7 +1518,7 @@ Yul Control Flow Graph: { "in": [ "0x40", - "v113" + "v112" ], "op": "mstore", "out": [] @@ -1527,39 +1526,39 @@ Yul Control Flow Graph: { "in": [ "v68", - "phi101" + "phi100" ], "op": "add", "out": [ - "v135" + "v134" ] }, { "in": [ - "v135", + "v134", "v68" ], "op": "sub", "out": [ - "v136" + "v135" ] }, { "in": [ - "v136", + "v135", "0x20" ], "op": "slt", "out": [ - "v137" + "v136" ] } ], "liveness": { "in": [ "v68", - "phi101", - "v113" + "phi100", + "v112" ], "out": [ "v68" @@ -1580,13 +1579,13 @@ Yul Control Flow Graph: ], "op": "shl", "out": [ - "v117" + "v116" ] }, { "in": [ "0x00", - "v117" + "v116" ], "op": "mstore", "out": [] @@ -1629,7 +1628,7 @@ Yul Control Flow Graph: ], "op": "mload", "out": [ - "v144" + "v143" ] } ], @@ -1638,7 +1637,7 @@ Yul Control Flow Graph: "v68" ], "out": [ - "v144" + "v143" ] }, "type": "BuiltinCall" diff --git a/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_0.asm b/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_0.asm new file mode 100644 index 000000000000..57438d83f10a --- /dev/null +++ b/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_0.asm @@ -0,0 +1,78 @@ + +PUSH 0x2 + +.sub + PUSH 0x1 + PUSH 0x1 + // random small integer: + PUSH 0x11f3d2be + // largest non-computable: + PUSH 0xffffffff + // smallest computable: + PUSH 0x100000000 + // Left shift: + PUSH 0x8000000000000 + PUSH 0x400000000000000000000000000000000000000000000 + PUSH 0x8000000000000000000000000000000000000000000000000000000000000000 + PUSH 0x20a1c0fc00000000000000000000000000000000000000000000000000000000 + // not: + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8ad0 + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 + PUSH 0xffffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffff + // PUSH0 NOT shift right: + PUSH 0x3ffffffff + PUSH 0x3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + // PUSH0 NOT shift left: + PUSH 0xffffffffffffffffffffffffffff000000000000000000000000000000000000 + PUSH 0xffffff0000000000000000000000000000000000000000000000000000000000 + // PUSH0 NOT shift right then left: + PUSH 0x1fffffffffffffffe0000000000000000000000000000000000000000000 + PUSH 0x7ffffffffffffff0000000000000000 + // or: + PUSH 0x1000000000000000030000000000000000000000000000000000000000000 + PUSH 0x100000000001000000000000100000000000 + PUSH 0xfffffffffffffffffffffffdffffffff0000000000000000ffffffffffffffff + PUSH 0xffffffffffffffffffffffff00000000ffffffffffffffffffffffff00000000 + PUSH 0x77abc0000000000000000000000000000000000000000000000000000000001 + // sub: + PUSH 0x3fffffffffffffffc0 + PUSH 0xffffffffffffffe0 +// ==== +// optimizationPreset: none +// optimizer.constantOptimizer: true +// optimizer.expectedExecutionsPerDeployment: 0 +// outputs: Assembly +// ---- +// Assembly: +// 0x02 +// stop +// +// sub_0: assembly { +// 0x01 +// 0x01 +// 0x11f3d2be +// 0xffffffff +// shl(0x20, 0x01) +// shl(0x33, 0x01) +// shl(0xb2, 0x01) +// shl(0xff, 0x01) +// shl(0xe2, 0x0828703f) +// not(0x00) +// not(0x752f) +// shl(0x20, not(0x00)) +// not(shl(0x40, 0xffffffff)) +// shr(0xde, not(0x00)) +// shr(0x06, not(0x00)) +// shl(0x90, not(0x00)) +// shl(0xe8, not(0x00)) +// shl(0xad, shr(0xc0, not(0x00))) +// shl(0x40, shr(0xc5, not(0x00))) +// shl(0xac, or(0x03, shl(0x44, 0x01))) +// shl(0x2c, or(0x01, shl(0x34, 0x100000000001))) +// not(shl(0x40, or(shr(0xc0, not(0x00)), shl(0x61, 0x01)))) +// or(shl(0x20, shr(0xa0, not(0x00))), shl(0xa0, not(0x00))) +// or(0x01, shl(0xea, 0x01deaf)) +// sub(shl(0x46, 0x01), 0x40) +// sub(shl(0x40, 0x01), 0x20) +// } diff --git a/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_200.asm b/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_200.asm new file mode 100644 index 000000000000..7b333dac2732 --- /dev/null +++ b/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_200.asm @@ -0,0 +1,74 @@ + +PUSH 0x2 + +.sub + // random small integer: + PUSH 0x11f3d2be + // largest non-computable: + PUSH 0xffffffff + // smallest computable: + PUSH 0x100000000 + // Left shift: + PUSH 0x8000000000000 + PUSH 0x400000000000000000000000000000000000000000000 + PUSH 0x8000000000000000000000000000000000000000000000000000000000000000 + PUSH 0x20a1c0fc00000000000000000000000000000000000000000000000000000000 + // not: + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8ad0 + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 + PUSH 0xffffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffff + // PUSH0 NOT shift right: + PUSH 0x3ffffffff + PUSH 0x3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + // PUSH0 NOT shift left: + PUSH 0xffffffffffffffffffffffffffff000000000000000000000000000000000000 + PUSH 0xffffff0000000000000000000000000000000000000000000000000000000000 + // PUSH0 NOT shift right then left: + PUSH 0x1fffffffffffffffe0000000000000000000000000000000000000000000 + PUSH 0x7ffffffffffffff0000000000000000 + // or: + PUSH 0x1000000000000000030000000000000000000000000000000000000000000 + PUSH 0x100000000001000000000000100000000000 + PUSH 0xfffffffffffffffffffffffdffffffff0000000000000000ffffffffffffffff + PUSH 0xffffffffffffffffffffffff00000000ffffffffffffffffffffffff00000000 + PUSH 0x77abc0000000000000000000000000000000000000000000000000000000001 + // sub: + PUSH 0x3fffffffffffffffc0 + PUSH 0xffffffffffffffe0 +// ==== +// optimizationPreset: none +// optimizer.constantOptimizer: true +// optimizer.expectedExecutionsPerDeployment: 200 +// outputs: Assembly +// ---- +// Assembly: +// 0x02 +// stop +// +// sub_0: assembly { +// 0x11f3d2be +// 0xffffffff +// 0x0100000000 +// 0x08000000000000 +// shl(0xb2, 0x01) +// shl(0xff, 0x01) +// shl(0xe2, 0x0828703f) +// not(0x00) +// not(0x752f) +// not(0xffffffff) +// not(0xffffffff0000000000000000) +// 0x03ffffffff +// shr(0x06, not(0x00)) +// shl(0x90, not(0x00)) +// shl(0xe8, 0xffffff) +// shl(0xad, 0xffffffffffffffff) +// 0x07ffffffffffffff0000000000000000 +// shl(0xac, 0x100000000000000003) +// 0x100000000001000000000000100000000000 +// not(0x0200000000ffffffffffffffff0000000000000000) +// not(0xffffffff000000000000000000000000ffffffff) +// or(0x01, shl(0xea, 0x01deaf)) +// 0x3fffffffffffffffc0 +// 0xffffffffffffffe0 +// } diff --git a/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_2M.asm b/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_2M.asm new file mode 100644 index 000000000000..4a93e395208f --- /dev/null +++ b/test/libevmasm/evmAssemblyTests/constant_optimizer_runs_2M.asm @@ -0,0 +1,73 @@ + +PUSH 0x2 + +.sub + PUSH 0x1 + PUSH 0x1 + // random small integer: + PUSH 0x11f3d2be + // largest non-computable: + PUSH 0xffffffff + // smallest computable: + PUSH 0x100000000 + // Left shift: + PUSH 0x8000000000000 + PUSH 0x400000000000000000000000000000000000000000000 + PUSH 0x8000000000000000000000000000000000000000000000000000000000000000 + PUSH 0x20a1c0fc00000000000000000000000000000000000000000000000000000000 + // not: + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8ad0 + PUSH 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 + PUSH 0xffffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffff + // PUSH0 NOT shift right: + PUSH 0x3ffffffff + PUSH 0x3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + // PUSH0 NOT shift right then left: + PUSH 0x1fffffffffffffffe0000000000000000000000000000000000000000000 + PUSH 0x7ffffffffffffff0000000000000000 + // or: + PUSH 0x1000000000000000030000000000000000000000000000000000000000000 + PUSH 0x100000000001000000000000100000000000 + PUSH 0xfffffffffffffffffffffffdffffffff0000000000000000ffffffffffffffff + PUSH 0xffffffffffffffffffffffff00000000ffffffffffffffffffffffff00000000 + PUSH 0x77abc0000000000000000000000000000000000000000000000000000000001 + // sub: + PUSH 0x3fffffffffffffffc0 + PUSH 0xffffffffffffffe0 +// ==== +// optimizationPreset: none +// optimizer.constantOptimizer: true +// optimizer.expectedExecutionsPerDeployment: 2000000 +// outputs: Assembly +// ---- +// Assembly: +// 0x02 +// stop +// +// sub_0: assembly { +// 0x01 +// 0x01 +// 0x11f3d2be +// 0xffffffff +// 0x0100000000 +// 0x08000000000000 +// 0x0400000000000000000000000000000000000000000000 +// 0x8000000000000000000000000000000000000000000000000000000000000000 +// 0x20a1c0fc00000000000000000000000000000000000000000000000000000000 +// 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +// 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8ad0 +// 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 +// 0xffffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffff +// 0x03ffffffff +// 0x03ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +// 0x1fffffffffffffffe0000000000000000000000000000000000000000000 +// 0x07ffffffffffffff0000000000000000 +// 0x01000000000000000030000000000000000000000000000000000000000000 +// 0x100000000001000000000000100000000000 +// 0xfffffffffffffffffffffffdffffffff0000000000000000ffffffffffffffff +// 0xffffffffffffffffffffffff00000000ffffffffffffffffffffffff00000000 +// 0x077abc0000000000000000000000000000000000000000000000000000000001 +// 0x3fffffffffffffffc0 +// 0xffffffffffffffe0 +// } diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_constant_optimizer.asmjson b/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_constant_optimizer.asmjson index a3610217fbaf..710f8da81c25 100644 --- a/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_constant_optimizer.asmjson +++ b/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_constant_optimizer.asmjson @@ -8,7 +8,7 @@ // optimizer.constantOptimizer: true // ---- // Assembly: -// sub(shl(0x40, 0x01), 0x01) -// Bytecode: 6001600160401b03 -// Opcodes: PUSH1 0x1 PUSH1 0x1 PUSH1 0x40 SHL SUB -// SourceMappings: :::-:0;;;; +// shr(0xc0, not(0x00)) +// Bytecode: 5f1960c01c +// Opcodes: PUSH0 NOT PUSH1 0xC0 SHR +// SourceMappings: :::-:0;;; diff --git a/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_expected_executions_per_deployment.asmjson b/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_expected_executions_per_deployment.asmjson index b9fd814d5c8e..780704849fb8 100644 --- a/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_expected_executions_per_deployment.asmjson +++ b/test/libevmasm/evmAssemblyTests/isoltestTesting/settings_optimizer_expected_executions_per_deployment.asmjson @@ -19,8 +19,8 @@ // stop // // sub_0: assembly { -// sub(shl(0x40, 0x01), 0x01) +// shr(0xc0, not(0x00)) // } -// Bytecode: 6003fe6001600160401b03 -// Opcodes: PUSH1 0x3 INVALID PUSH1 0x1 PUSH1 0x1 PUSH1 0x40 SHL SUB +// Bytecode: 6003fe5f1960c01c +// Opcodes: PUSH1 0x3 INVALID PUSH0 NOT PUSH1 0xC0 SHR // SourceMappings: :::-:0 diff --git a/test/libsolidity/gasTests/abiv2_optimised.sol b/test/libsolidity/gasTests/abiv2_optimised.sol index b5f080862b49..642abb4936ef 100644 --- a/test/libsolidity/gasTests/abiv2_optimised.sol +++ b/test/libsolidity/gasTests/abiv2_optimised.sol @@ -18,9 +18,9 @@ contract C { // optimize-yul: true // ---- // creation: -// codeDepositCost: 618200 -// executionCost: 649 -// totalCost: 618849 +// codeDepositCost: 605600 +// executionCost: 636 +// totalCost: 606236 // external: // a(): 2283 // b(uint256): 4649 diff --git a/test/libsolidity/semanticTests/abicoder/abi_decode_from_storage_struct_v2.sol b/test/libsolidity/semanticTests/abicoder/abi_decode_from_storage_struct_v2.sol index e4b9539d963b..ee0d42b30681 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_decode_from_storage_struct_v2.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_decode_from_storage_struct_v2.sol @@ -21,7 +21,7 @@ contract C { } // ---- // f() -> 0x20, 0x8, 0x40, 0x3, 0x9, 0xa, 0xb -// gas irOptimized: 203109 +// gas irOptimized: 203197 // gas legacy: 206263 -// gas legacyOptimized: 203177 -// gas ssaCFGOptimized: 202890 +// gas legacyOptimized: 203225 +// gas ssaCFGOptimized: 202978 diff --git a/test/libsolidity/semanticTests/abicoder/abi_decode_simple_storage.sol b/test/libsolidity/semanticTests/abicoder/abi_decode_simple_storage.sol index 605cc66ec2d5..821355759da4 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_decode_simple_storage.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_decode_simple_storage.sol @@ -8,7 +8,7 @@ contract C { } // ---- // f(bytes): 0x20, 0x80, 0x21, 0x40, 0x7, "abcdefg" -> 0x21, 0x40, 0x7, "abcdefg" -// gas irOptimized: 135441 +// gas irOptimized: 135505 // gas legacy: 137095 -// gas legacyOptimized: 135828 -// gas ssaCFGOptimized: 135333 +// gas legacyOptimized: 135884 +// gas ssaCFGOptimized: 135397 diff --git a/test/libsolidity/semanticTests/abicoder/abi_encode_calldata_slice.sol b/test/libsolidity/semanticTests/abicoder/abi_encode_calldata_slice.sol index 5f492debc859..71fd3e24a8f5 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_encode_calldata_slice.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_encode_calldata_slice.sol @@ -59,12 +59,12 @@ contract C { // EVMVersion: >homestead // ---- // test_bytes() -> -// gas irOptimized: 314884 +// gas irOptimized: 302904 // gas legacy: 305816 -// gas legacyOptimized: 253573 -// gas ssaCFGOptimized: 311064 +// gas legacyOptimized: 244887 +// gas ssaCFGOptimized: 299084 // test_uint256() -> -// gas irOptimized: 448346 +// gas irOptimized: 428338 // gas legacy: 421304 -// gas legacyOptimized: 351544 -// gas ssaCFGOptimized: 440615 +// gas legacyOptimized: 337032 +// gas ssaCFGOptimized: 420607 diff --git a/test/libsolidity/semanticTests/abicoder/abi_encode_storage_array_v2.sol b/test/libsolidity/semanticTests/abicoder/abi_encode_storage_array_v2.sol index dab9ca61ad3b..30828d6686d2 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_encode_storage_array_v2.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_encode_storage_array_v2.sol @@ -18,12 +18,12 @@ contract C { // EVMVersion: >homestead // ---- // h(uint256[2][]): 0x20, 3, 123, 124, 223, 224, 323, 324 -> 32, 256, 0x20, 3, 123, 124, 223, 224, 323, 324 -// gas irOptimized: 180022 +// gas irOptimized: 180046 // gas legacy: 186541 // gas legacyOptimized: 180429 -// gas ssaCFGOptimized: 180004 +// gas ssaCFGOptimized: 180028 // i(uint256[2][2]): 123, 124, 223, 224 -> 32, 128, 123, 124, 223, 224 -// gas irOptimized: 112031 +// gas irOptimized: 112039 // gas legacy: 116683 // gas legacyOptimized: 112303 -// gas ssaCFGOptimized: 112034 +// gas ssaCFGOptimized: 112042 diff --git a/test/libsolidity/semanticTests/abicoder/abi_encode_v2.sol b/test/libsolidity/semanticTests/abicoder/abi_encode_v2.sol index 18ba824830a3..bd7e66c85685 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_encode_v2.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_encode_v2.sol @@ -50,7 +50,7 @@ contract C { // f2() -> 0x20, 0xa0, 0x1, 0x60, 0x2, 0x3, "abc" // f3() -> 0x20, 0xa0, 0x1, 0x60, 0x2, 0x3, "abc" // f4() -> 0x20, 0x160, 0x1, 0x80, 0xc0, 0x2, 0x3, "abc", 0x7, 0x40, 0x2, 0x2, 0x3 -// gas irOptimized: 111816 +// gas irOptimized: 111807 // gas legacy: 113890 -// gas legacyOptimized: 111658 -// gas ssaCFGOptimized: 111829 +// gas legacyOptimized: 111649 +// gas ssaCFGOptimized: 111820 diff --git a/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_function_inherited_in_v1_contract.sol b/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_function_inherited_in_v1_contract.sol index 536021066f05..e695fea5c3d7 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_function_inherited_in_v1_contract.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_function_inherited_in_v1_contract.sol @@ -30,11 +30,11 @@ contract C is B { } // ---- // test() -> 77 -// gas irOptimized: 55117 -// gas irOptimized code: 56800 +// gas irOptimized: 55177 +// gas irOptimized code: 54400 // gas legacy: 57266 // gas legacy code: 94600 -// gas legacyOptimized: 55195 +// gas legacyOptimized: 55191 // gas legacyOptimized code: 55000 -// gas ssaCFGOptimized: 55059 -// gas ssaCFGOptimized code: 56400 +// gas ssaCFGOptimized: 55119 +// gas ssaCFGOptimized code: 54000 diff --git a/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_modifier_used_in_v1_contract.sol b/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_modifier_used_in_v1_contract.sol index 78da59648a9d..a02a388562a6 100644 --- a/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_modifier_used_in_v1_contract.sol +++ b/test/libsolidity/semanticTests/abicoder/abi_encode_v2_in_modifier_used_in_v1_contract.sol @@ -38,7 +38,7 @@ contract C is B { } // ---- // test() -> 5, 10 -// gas irOptimized: 65040 +// gas irOptimized: 65076 // gas irOptimized code: 26200 // gas legacy: 66250 // gas legacy code: 36400 diff --git a/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_array_dynamic_of_uint_v2.sol b/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_array_dynamic_of_uint_v2.sol index 57ac5f60888a..e2842805fe3b 100644 --- a/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_array_dynamic_of_uint_v2.sol +++ b/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_array_dynamic_of_uint_v2.sol @@ -20,7 +20,7 @@ contract C { // f(uint256[][1]): 32, 32, 0 -> true // f(uint256[][1]): 32, 32, 1, 42 -> true // f(uint256[][1]): 32, 32, 8, 421, 422, 423, 424, 425, 426, 427, 428 -> true -// gas irOptimized: 120978 +// gas irOptimized: 115310 // gas legacy: 98324 -// gas legacyOptimized: 94348 -// gas ssaCFGOptimized: 124138 +// gas legacyOptimized: 90236 +// gas ssaCFGOptimized: 121386 diff --git a/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_overlapping_dynamic_arrays_v2.sol b/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_overlapping_dynamic_arrays_v2.sol index 2c8e8933d6ba..be23dde1d19d 100644 --- a/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_overlapping_dynamic_arrays_v2.sol +++ b/test/libsolidity/semanticTests/abicoder/calldataDecoding/array/calldata_overlapping_dynamic_arrays_v2.sol @@ -33,9 +33,9 @@ contract C { // f_which(uint256[],uint256[2],uint256): 0x40, 1, 2, 1, 5, 6 -> 0x20, 0x40, 5, 2 // f_which(uint256[],uint256[2],uint256): 0x40, 1, 2, 1 -> FAILURE // f_storage(uint256[],uint256[2]): 0x20, 1, 2 -> 0x20, 0x60, 0x20, 1, 2 -// gas irOptimized: 111356 +// gas irOptimized: 111388 // gas legacy: 113826 -// gas legacyOptimized: 111724 -// gas ssaCFGOptimized: 111349 +// gas legacyOptimized: 111748 +// gas ssaCFGOptimized: 111381 // f_storage(uint256[],uint256[2]): 0x40, 1, 2, 5, 6 -> 0x20, 0x80, 0x20, 2, 5, 6 // f_storage(uint256[],uint256[2]): 0x40, 1, 2, 5 -> FAILURE diff --git a/test/libsolidity/semanticTests/abicoder/calldataDecoding/copy_from_calldata_removes_bytes_data.sol b/test/libsolidity/semanticTests/abicoder/calldataDecoding/copy_from_calldata_removes_bytes_data.sol index 84ba41274fd1..5d34c8dca1ca 100644 --- a/test/libsolidity/semanticTests/abicoder/calldataDecoding/copy_from_calldata_removes_bytes_data.sol +++ b/test/libsolidity/semanticTests/abicoder/calldataDecoding/copy_from_calldata_removes_bytes_data.sol @@ -9,11 +9,11 @@ contract c { // EVMVersion: >=byzantium // ---- // (): 1, 2, 3, 4, 5 -> -// gas irOptimized: 155122 +// gas irOptimized: 155130 // gas legacy: 155473 // gas legacyOptimized: 155296 -// gas ssaCFGOptimized: 155110 +// gas ssaCFGOptimized: 155118 // checkIfDataIsEmpty() -> false // sendMessage() -> true, 0x40, 0 -// gas irOptimized: 41925 +// gas irOptimized: 41932 // checkIfDataIsEmpty() -> true diff --git a/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol b/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol index 836db9e92725..14e128713a3c 100644 --- a/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol +++ b/test/libsolidity/semanticTests/array/array_storage_push_empty_length_address.sol @@ -17,9 +17,9 @@ contract C { // set_get_length(uint256): 10 -> 10 // set_get_length(uint256): 20 -> 20 // set_get_length(uint256): 0 -> 0 -// gas irOptimized: 76123 +// gas irOptimized: 76043 // gas legacy: 75618 -// gas legacyOptimized: 75076 +// gas legacyOptimized: 74936 // set_get_length(uint256): 0xFF -> 0xFF // gas irOptimized: 168565 // gas legacy: 696850 diff --git a/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol b/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol index 0029332400d4..9a077ebefa32 100644 --- a/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol +++ b/test/libsolidity/semanticTests/array/arrays_complex_from_and_to_storage.sol @@ -12,10 +12,10 @@ contract Test { } // ---- // set(uint24[3][]): 0x20, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12 -> 0x06 -// gas irOptimized: 185221 +// gas irOptimized: 185293 // gas legacy: 199970 -// gas legacyOptimized: 186342 -// gas ssaCFGOptimized: 185206 +// gas legacyOptimized: 186414 +// gas ssaCFGOptimized: 185278 // data(uint256,uint256): 0x02, 0x02 -> 0x09 // data(uint256,uint256): 0x05, 0x01 -> 0x11 // data(uint256,uint256): 0x06, 0x00 -> FAILURE diff --git a/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol b/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol index e87ee92cf1b4..ecd66cc8c895 100644 --- a/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol +++ b/test/libsolidity/semanticTests/array/byte_array_transitional_2.sol @@ -19,5 +19,5 @@ contract c { // test() -> 0 // gas irOptimized: 122717 // gas legacy: 147108 -// gas legacyOptimized: 144200 -// gas ssaCFGOptimized: 123766 +// gas legacyOptimized: 143790 +// gas ssaCFGOptimized: 123536 diff --git a/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol b/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol index 41f77ba1a4c2..44a29cb2f1db 100644 --- a/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol +++ b/test/libsolidity/semanticTests/array/constant_var_as_array_length.sol @@ -8,13 +8,13 @@ contract C { } // ---- // constructor(): 1, 2, 3 -> -// gas irOptimized: 124991 +// gas irOptimized: 124887 // gas irOptimized code: 14800 // gas legacy: 142553 // gas legacy code: 46200 -// gas legacyOptimized: 126306 +// gas legacyOptimized: 126254 // gas legacyOptimized code: 23400 -// gas ssaCFGOptimized: 124797 +// gas ssaCFGOptimized: 124693 // gas ssaCFGOptimized code: 13200 // a(uint256): 0 -> 1 // a(uint256): 1 -> 2 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint128.sol b/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint128.sol index ba05d8fb670d..f1d78444f519 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint128.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint128.sol @@ -21,6 +21,6 @@ contract C { } // ---- // f() -> true -// gas irOptimized: 73981 +// gas irOptimized: 73944 // gas legacy: 75550 -// gas legacyOptimized: 73812 +// gas legacyOptimized: 73786 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol b/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol index e0b35a670d9c..6e8cc6930c17 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_cleanup_uint40.sol @@ -46,7 +46,7 @@ contract C { } // ---- // f() -> true -// gas irOptimized: 122596 +// gas irOptimized: 122865 // gas legacy: 125651 -// gas legacyOptimized: 121668 -// gas ssaCFGOptimized: 122652 +// gas legacyOptimized: 121944 +// gas ssaCFGOptimized: 122915 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage_packed.sol b/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage_packed.sol index 12d9bf1fd3c0..226df7994bf2 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage_packed.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_clear_storage_packed.sol @@ -40,11 +40,11 @@ contract C { } // ---- // f() -> 0 -// gas irOptimized: 74044 +// gas irOptimized: 74020 // gas legacy: 75528 -// gas legacyOptimized: 73861 +// gas legacyOptimized: 73829 // g() -> 0 // h() -> 0 -// gas irOptimized: 74114 +// gas irOptimized: 74086 // gas legacy: 75553 -// gas legacyOptimized: 73904 +// gas legacyOptimized: 73872 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol b/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol index 9f5409b707e9..e47b1ffb6f57 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_different_packing.sol @@ -18,7 +18,7 @@ contract c { } // ---- // test() -> 0x01000000000000000000000000000000000000000000000000, 0x02000000000000000000000000000000000000000000000000, 0x03000000000000000000000000000000000000000000000000, 0x04000000000000000000000000000000000000000000000000, 0x05000000000000000000000000000000000000000000000000 -// gas irOptimized: 208415 +// gas irOptimized: 208599 // gas legacy: 220059 -// gas legacyOptimized: 211458 -// gas ssaCFGOptimized: 208067 +// gas legacyOptimized: 211620 +// gas ssaCFGOptimized: 208251 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol index 271ca44d01ce..e6a1328a8766 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base.sol @@ -17,7 +17,7 @@ contract c { } // ---- // test() -> 5, 4 -// gas irOptimized: 205667 +// gas irOptimized: 205763 // gas legacy: 207971 -// gas legacyOptimized: 204828 -// gas ssaCFGOptimized: 205682 +// gas legacyOptimized: 204892 +// gas ssaCFGOptimized: 205778 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol index 2884df923ba5..26bb86e7cb3d 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_different_base_nested.sol @@ -21,7 +21,7 @@ contract c { } // ---- // test() -> 3, 4 -// gas irOptimized: 169553 +// gas irOptimized: 169421 // gas legacy: 182361 -// gas legacyOptimized: 169554 -// gas ssaCFGOptimized: 169608 +// gas legacyOptimized: 169490 +// gas ssaCFGOptimized: 169313 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol index 85bc291c5132..5e0ad069f0ef 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_dyn_dyn.sol @@ -15,10 +15,10 @@ contract c { // ---- // setData1(uint256,uint256,uint256): 10, 5, 4 -> // copyStorageStorage() -> -// gas irOptimized: 111321 +// gas irOptimized: 111329 // gas legacy: 112434 -// gas legacyOptimized: 111494 -// gas ssaCFGOptimized: 111318 +// gas legacyOptimized: 111502 +// gas ssaCFGOptimized: 111326 // getData2(uint256): 5 -> 10, 4 // setData1(uint256,uint256,uint256): 0, 0, 0 -> // copyStorageStorage() -> diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol index 29e62dd3ce8f..a969a02a2f62 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_static_simple.sol @@ -12,4 +12,4 @@ contract C { // ---- // test() -> left(0x01), left(0x02) // gas legacy: 69235 -// gas legacyOptimized: 66974 +// gas legacyOptimized: 66965 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol index 6acb4856030f..bd465038d846 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_storage_storage_struct.sol @@ -17,8 +17,8 @@ contract c { } // ---- // test() -> 4, 5 -// gas irOptimized: 190676 +// gas irOptimized: 190670 // gas legacy: 210706 -// gas legacyOptimized: 190472 -// gas ssaCFGOptimized: 190656 +// gas legacyOptimized: 190465 +// gas ssaCFGOptimized: 190650 // storageEmpty -> 1 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol b/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol index 9ee7a0a6bd62..a68c01913e8d 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover.sol @@ -17,7 +17,7 @@ contract c { } // ---- // test() -> 0xffffffff, 0x0000000000000000000000000a00090008000700060005000400030002000100, 0x0000000000000000000000000000000000000000000000000000000000000000 -// gas irOptimized: 100506 +// gas irOptimized: 100502 // gas legacy: 146700 -// gas legacyOptimized: 122680 -// gas ssaCFGOptimized: 100380 +// gas legacyOptimized: 122388 +// gas ssaCFGOptimized: 100376 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol b/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol index 706130082fff..8067d4ae6897 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_target_leftover2.sol @@ -19,6 +19,6 @@ contract c { } // ---- // test() -> 0x04000000000000000000000000000000000000000000000000, 0x0, 0x0 -// gas irOptimized: 91320 +// gas irOptimized: 91401 // gas legacy: 97777 -// gas legacyOptimized: 91993 +// gas legacyOptimized: 92074 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol b/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol index 5576e88f734b..c2895492ad03 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_target_simple.sol @@ -18,7 +18,7 @@ contract c { } // ---- // test() -> 0x01000000000000000000000000000000000000000000000000, 0x02000000000000000000000000000000000000000000000000, 0x03000000000000000000000000000000000000000000000000, 0x04000000000000000000000000000000000000000000000000, 0x0 -// gas irOptimized: 273548 +// gas irOptimized: 273488 // gas legacy: 280148 -// gas legacyOptimized: 274502 -// gas ssaCFGOptimized: 273666 +// gas legacyOptimized: 274512 +// gas ssaCFGOptimized: 273638 diff --git a/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol b/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol index ba2faf2cde48..4e151d0fef29 100644 --- a/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol +++ b/test/libsolidity/semanticTests/array/copying/array_copy_target_simple_2.sol @@ -18,7 +18,7 @@ contract c { } // ---- // test() -> 0x01000000000000000000000000000000000000000000000000, 0x02000000000000000000000000000000000000000000000000, 0x03000000000000000000000000000000000000000000000000, 0x04000000000000000000000000000000000000000000000000, 0x00 -// gas irOptimized: 233012 +// gas irOptimized: 233068 // gas legacy: 239400 -// gas legacyOptimized: 233948 -// gas ssaCFGOptimized: 233127 +// gas legacyOptimized: 233871 +// gas ssaCFGOptimized: 233183 diff --git a/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol b/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol index 5ab832084547..39c39f07a5f7 100644 --- a/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol +++ b/test/libsolidity/semanticTests/array/copying/array_elements_to_mapping.sol @@ -52,10 +52,10 @@ contract C { } // ---- // from_storage() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -// gas irOptimized: 149856 +// gas irOptimized: 149928 // gas legacy: 156721 -// gas legacyOptimized: 149000 -// gas ssaCFGOptimized: 149664 +// gas legacyOptimized: 149032 +// gas ssaCFGOptimized: 149736 // from_storage_ptr() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 // from_memory() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 // from_calldata(uint8[][]): 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 diff --git a/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol b/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol index 84bd287bf022..efd548159213 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic.sol @@ -45,8 +45,8 @@ contract C { } // ---- // copyExternalStorageArrayOfFunctionType() -> true -// gas irOptimized: 104629 +// gas irOptimized: 104717 // gas legacy: 111170 -// gas legacyOptimized: 104620 -// gas ssaCFGOptimized: 104602 +// gas legacyOptimized: 104604 +// gas ssaCFGOptimized: 104690 // copyInternalArrayOfFunctionType() -> true diff --git a/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol b/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol index 9878a0e569c9..fcc015156407 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_function_external_storage_to_storage_dynamic_different_mutability.sol @@ -48,9 +48,9 @@ contract C { } // ---- // copyExternalStorageArraysOfFunctionType() -> true -// gas irOptimized: 104238 +// gas irOptimized: 104326 // gas legacy: 110911 -// gas legacyOptimized: 104377 -// gas ssaCFGOptimized: 104351 +// gas legacyOptimized: 104361 +// gas ssaCFGOptimized: 104439 // copyInternalArrayOfFunctionType() -> true // gas legacy: 38695 diff --git a/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol index c05939136b7f..f457d7db9b26 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_struct_calldata_to_storage.sol @@ -17,5 +17,5 @@ contract C { // compileViaYul: true // ---- // f((uint128,uint64,uint128)[]): 0x20, 3, 0, 0, 12, 0, 11, 0, 10, 0, 0 -> 10, 11, 12 -// gas irOptimized: 120751 -// gas ssaCFGOptimized: 120684 +// gas irOptimized: 120709 +// gas ssaCFGOptimized: 120671 diff --git a/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol index 764a5d207dab..e6f961ae635f 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_struct_memory_to_storage.sol @@ -19,5 +19,5 @@ contract C { // compileViaYul: true // ---- // f() -> 10, 11, 12 -// gas irOptimized: 118796 -// gas ssaCFGOptimized: 118739 +// gas irOptimized: 118746 +// gas ssaCFGOptimized: 118727 diff --git a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol index 297703c765ed..7780b90a8358 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_calldata_to_storage.sol @@ -23,5 +23,5 @@ contract C { // compileViaYul: true // ---- // f((uint256[])[]): 0x20, 3, 0x60, 0x60, 0x60, 0x20, 3, 1, 2, 3 -> 3, 1 -// gas irOptimized: 327461 -// gas ssaCFGOptimized: 327419 +// gas irOptimized: 327621 +// gas ssaCFGOptimized: 327579 diff --git a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol index 56582a402666..ca99d7f40647 100644 --- a/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/array_of_structs_containing_arrays_memory_to_storage.sol @@ -26,5 +26,5 @@ contract C { // compileViaYul: true // ---- // f() -> 3, 3, 3, 1 -// gas irOptimized: 181928 -// gas ssaCFGOptimized: 182440 +// gas irOptimized: 181881 +// gas ssaCFGOptimized: 181787 diff --git a/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol b/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol index 9817157e906e..3dc2da9d7458 100644 --- a/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol +++ b/test/libsolidity/semanticTests/array/copying/array_storage_multi_items_per_slot.sol @@ -12,7 +12,7 @@ contract C { } // ---- // f() -> 1, 2, 3 -// gas irOptimized: 131939 +// gas irOptimized: 131953 // gas legacy: 134605 -// gas legacyOptimized: 131938 -// gas ssaCFGOptimized: 131989 +// gas legacyOptimized: 131952 +// gas ssaCFGOptimized: 132003 diff --git a/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol b/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol index c34082a6cf6d..7eb1b9b4cd68 100644 --- a/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol +++ b/test/libsolidity/semanticTests/array/copying/array_to_mapping.sol @@ -37,9 +37,9 @@ contract C { } // ---- // from_storage() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -// gas irOptimized: 147749 +// gas irOptimized: 147797 // gas legacy: 154218 // gas legacyOptimized: 147020 -// gas ssaCFGOptimized: 147492 +// gas ssaCFGOptimized: 147540 // from_storage_ptr() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 // from_memory() -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 diff --git a/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol b/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol index fea2c895d81c..af799ef5a31e 100644 --- a/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/arrays_from_and_to_storage.sol @@ -10,9 +10,9 @@ contract Test { } // ---- // set(uint24[]): 0x20, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 -> 18 -// gas irOptimized: 95505 +// gas irOptimized: 95537 // gas legacy: 104176 -// gas legacyOptimized: 96785 +// gas legacyOptimized: 96817 // data(uint256): 7 -> 8 // data(uint256): 15 -> 16 // data(uint256): 18 -> FAILURE diff --git a/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol b/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol index 96535fc07ebc..bf8913c2c38b 100644 --- a/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/bytes_storage_to_storage.sol @@ -17,31 +17,31 @@ contract c { // ---- // f(uint256): 0 -> 0x20, 0x00 // f(uint256): 31 -> 0x20, 0x1f, 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e00 -// gas irOptimized: 103268 +// gas irOptimized: 103037 // gas legacy: 112904 -// gas legacyOptimized: 112645 -// gas ssaCFGOptimized: 103499 +// gas legacyOptimized: 111739 +// gas ssaCFGOptimized: 102710 // f(uint256): 32 -> 0x20, 0x20, 1780731860627700044960722568376592200742329637303199754547598369979440671 -// gas irOptimized: 117825 +// gas irOptimized: 117585 // gas legacy: 128964 -// gas legacyOptimized: 128859 -// gas ssaCFGOptimized: 117766 +// gas legacyOptimized: 127923 +// gas ssaCFGOptimized: 116950 // f(uint256): 33 -> 0x20, 33, 1780731860627700044960722568376592200742329637303199754547598369979440671, 0x2000000000000000000000000000000000000000000000000000000000000000 -// gas irOptimized: 123888 +// gas irOptimized: 123639 // gas legacy: 135510 -// gas legacyOptimized: 135218 -// gas ssaCFGOptimized: 123801 +// gas legacyOptimized: 134252 +// gas ssaCFGOptimized: 122958 // f(uint256): 63 -> 0x20, 0x3f, 1780731860627700044960722568376592200742329637303199754547598369979440671, 14532552714582660066924456880521368950258152170031413196862950297402215316992 -// gas irOptimized: 126948 +// gas irOptimized: 126429 // gas legacy: 148110 -// gas legacyOptimized: 148448 -// gas ssaCFGOptimized: 126921 +// gas legacyOptimized: 146582 +// gas ssaCFGOptimized: 125268 // f(uint256): 12 -> 0x20, 0x0c, 0x0102030405060708090a0b0000000000000000000000000000000000000000 -// gas irOptimized: 54204 +// gas irOptimized: 54156 // gas legacy: 59832 -// gas legacyOptimized: 57268 +// gas legacyOptimized: 56999 // f(uint256): 129 -> 0x20, 0x81, 1780731860627700044960722568376592200742329637303199754547598369979440671, 0x202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f, 29063324697304692433803953038474361308315562010425523193971352996434451193439, 0x606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f, -57896044618658097711785492504343953926634992332820282019728792003956564819968 -// gas irOptimized: 416918 +// gas irOptimized: 415805 // gas legacy: 458997 -// gas legacyOptimized: 460669 -// gas ssaCFGOptimized: 416960 +// gas legacyOptimized: 456823 +// gas ssaCFGOptimized: 413525 diff --git a/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol b/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol index 427513428cfa..035d31734234 100644 --- a/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/calldata_array_dynamic_to_storage.sol @@ -11,5 +11,5 @@ contract C { // f(uint256[]): 0x20, 0x03, 0x1, 0x2, 0x3 -> 0x1 // gas irOptimized: 110973 // gas legacy: 112436 -// gas legacyOptimized: 111313 +// gas legacyOptimized: 111337 // gas ssaCFGOptimized: 110964 diff --git a/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol b/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol index cdd111e84ba4..40cb6c3d58d0 100644 --- a/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol +++ b/test/libsolidity/semanticTests/array/copying/calldata_array_to_mapping.sol @@ -14,5 +14,5 @@ contract C { // compileViaYul: true // ---- // from_calldata(uint8[][]): 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -> 0x20, 2, 0x40, 0xa0, 2, 10, 11, 3, 12, 13, 14 -// gas irOptimized: 139587 -// gas ssaCFGOptimized: 139335 +// gas irOptimized: 139651 +// gas ssaCFGOptimized: 139399 diff --git a/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol b/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol index 802506c74f6c..729149ea1563 100644 --- a/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/copy_byte_array_in_struct_to_storage.sol @@ -35,15 +35,15 @@ contract C { } // ---- // f() -> 0x40, 0x80, 6, 0x6162636465660000000000000000000000000000000000000000000000000000, 0x49, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738390000000000000000000000000000000000000000000000 -// gas irOptimized: 179405 +// gas irOptimized: 179461 // gas legacy: 180675 // gas legacyOptimized: 179690 -// gas ssaCFGOptimized: 179339 +// gas ssaCFGOptimized: 179395 // g() -> 0x40, 0xc0, 0x49, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738393031323334353637383930313233343536373839303120, 0x3132333435363738390000000000000000000000000000000000000000000000, 0x11, 0x3132333435363738393233343536373839000000000000000000000000000000 -// gas irOptimized: 106381 +// gas irOptimized: 106437 // gas legacy: 109472 // gas legacyOptimized: 106648 -// gas ssaCFGOptimized: 106266 +// gas ssaCFGOptimized: 106322 // h() -> 0x40, 0x60, 0x00, 0x00 -// gas irOptimized: 46948 +// gas irOptimized: 46980 // storageEmpty -> 1 diff --git a/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol b/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol index 7a49f55aea92..25336eca1655 100644 --- a/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol +++ b/test/libsolidity/semanticTests/array/copying/copy_function_internal_storage_array.sol @@ -15,7 +15,7 @@ contract C { } // ---- // test() -> 7 -// gas irOptimized: 122575 +// gas irOptimized: 122687 // gas legacy: 208558 -// gas legacyOptimized: 202409 -// gas ssaCFGOptimized: 122221 +// gas legacyOptimized: 202529 +// gas ssaCFGOptimized: 122333 diff --git a/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol b/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol index 104ad5b93f22..b17eb69b5639 100644 --- a/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol +++ b/test/libsolidity/semanticTests/array/copying/copying_bytes_multiassign.sol @@ -18,16 +18,16 @@ contract sender { } // ---- // (): 7 -> -// gas irOptimized: 110735 +// gas irOptimized: 110751 // gas legacy: 111388 // gas legacyOptimized: 111066 -// gas ssaCFGOptimized: 110716 +// gas ssaCFGOptimized: 110732 // val() -> 0 // forward(bool): true -> true -// gas irOptimized: 49573 +// gas irOptimized: 49569 // val() -> 0x80 // forward(bool): false -> true -// gas irOptimized: 31410 +// gas irOptimized: 31407 // val() -> 0x80 // forward(bool): true -> true // val() -> 0x80 diff --git a/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol index 9bcee4e0cd4f..ceba0174ec35 100644 --- a/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_calldata_to_storage.sol @@ -31,11 +31,11 @@ contract C { // compileViaYul: true // ---- // test1((uint8[],uint8[2])[][][]): 0x20, 1, 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -// gas irOptimized: 327936 -// gas ssaCFGOptimized: 327488 +// gas irOptimized: 328144 +// gas ssaCFGOptimized: 327696 // test2((uint8[],uint8[2])[][1][]): 0x20, 2, 0x40, 0x0160, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13, 0x20, 1, 0x20, 0x60, 31, 37, 2, 23, 29 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 141168 -// gas ssaCFGOptimized: 140845 +// gas irOptimized: 141264 +// gas ssaCFGOptimized: 140941 // test3((uint8[],uint8[2])[1][][2]): 0x20, 0x40, 0x60, 0, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 188448 -// gas ssaCFGOptimized: 188221 +// gas irOptimized: 188576 +// gas ssaCFGOptimized: 188349 diff --git a/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol b/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol index 1e0ce2b83b6c..acfa46e72190 100644 --- a/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/elements_of_nested_array_of_structs_memory_to_storage.sol @@ -31,11 +31,11 @@ contract C { // compileViaYul: true // ---- // test1((uint8[],uint8[2])[][][]): 0x20, 1, 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -// gas irOptimized: 332582 -// gas ssaCFGOptimized: 331861 +// gas irOptimized: 332390 +// gas ssaCFGOptimized: 331669 // test2((uint8[],uint8[2])[][1][]): 0x20, 2, 0x40, 0x0160, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13, 0x20, 1, 0x20, 0x60, 31, 37, 2, 23, 29 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 145415 -// gas ssaCFGOptimized: 144978 +// gas irOptimized: 145283 +// gas ssaCFGOptimized: 144846 // test3((uint8[],uint8[2])[1][][2]): 0x20, 0x40, 0x60, 0, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 288, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 192254 -// gas ssaCFGOptimized: 191783 +// gas irOptimized: 192110 +// gas ssaCFGOptimized: 191639 diff --git a/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol b/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol index 5545c30e32ff..c1cb77bcdf4c 100644 --- a/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/function_type_array_to_storage.sol @@ -46,13 +46,13 @@ contract C { } // ---- // test() -> 0x20, 0x14, "[a called][b called]" -// gas irOptimized: 116512 +// gas irOptimized: 116616 // gas legacy: 120226 -// gas legacyOptimized: 116941 -// gas ssaCFGOptimized: 116470 +// gas legacyOptimized: 117001 +// gas ssaCFGOptimized: 116539 // test2() -> 0x20, 0x14, "[b called][a called]" // test3() -> 0x20, 0x14, "[b called][a called]" -// gas irOptimized: 103138 +// gas irOptimized: 103186 // gas legacy: 105192 -// gas legacyOptimized: 103752 -// gas ssaCFGOptimized: 103069 +// gas legacyOptimized: 103768 +// gas ssaCFGOptimized: 103117 diff --git a/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol b/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol index 88545895fe89..29ca3cc2bb20 100644 --- a/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/memory_dyn_2d_bytes_to_storage.sol @@ -18,7 +18,7 @@ contract C { } // ---- // f() -> 3 -// gas irOptimized: 128301 +// gas irOptimized: 128211 // gas legacy: 129528 -// gas legacyOptimized: 128171 -// gas ssaCFGOptimized: 128250 +// gas legacyOptimized: 128041 +// gas ssaCFGOptimized: 128160 diff --git a/test/libsolidity/semanticTests/array/copying/nested_array_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/nested_array_calldata_to_storage.sol index ed11fc06838d..2bb2f368317e 100644 --- a/test/libsolidity/semanticTests/array/copying/nested_array_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/nested_array_calldata_to_storage.sol @@ -38,14 +38,14 @@ contract c { // compileViaYul: true // ---- // test1(uint256[][]): 0x20, 2, 0x40, 0x40, 2, 23, 42 -> 2, 65 -// gas irOptimized: 180918 -// gas ssaCFGOptimized: 180871 +// gas irOptimized: 180982 +// gas ssaCFGOptimized: 180935 // test2(uint256[][2]): 0x20, 0x40, 0x40, 2, 23, 42 -> 2, 65 -// gas irOptimized: 157604 -// gas ssaCFGOptimized: 157563 +// gas irOptimized: 157660 +// gas ssaCFGOptimized: 157619 // test3(uint256[2][]): 0x20, 2, 23, 42, 23, 42 -> 2, 65 -// gas irOptimized: 134685 -// gas ssaCFGOptimized: 134831 +// gas irOptimized: 134701 +// gas ssaCFGOptimized: 134847 // test4(uint256[2][2]): 23, 42, 23, 42 -> 65 // gas irOptimized: 111177 // gas ssaCFGOptimized: 111192 diff --git a/test/libsolidity/semanticTests/array/copying/nested_array_dynamic_dynamic_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/nested_array_dynamic_dynamic_calldata_to_storage.sol index 5325b56a7946..f6896c0f6edf 100644 --- a/test/libsolidity/semanticTests/array/copying/nested_array_dynamic_dynamic_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/nested_array_dynamic_dynamic_calldata_to_storage.sol @@ -8,7 +8,7 @@ contract C { // compileViaYul: true // ---- // i(uint256[][]): 0x20, 2, 0x40, 0xC0, 3, 0x0A01, 0x0A02, 0x0A03, 4, 0x0B01, 0x0B02, 0x0B03, 0x0B04 -// gas irOptimized: 245511 -// gas ssaCFGOptimized: 245497 +// gas irOptimized: 245543 +// gas ssaCFGOptimized: 245529 // tmp_i(uint256,uint256): 0, 0 -> 0x0A01 // tmp_i(uint256,uint256): 1, 0 -> 0x0B01 diff --git a/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol index 4f22203f1e72..ee5666344326 100644 --- a/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_calldata_to_storage.sol @@ -29,11 +29,11 @@ contract C { // compileViaYul: true // ---- // test1((uint8[],uint8[2])[][]): 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -// gas irOptimized: 304750 -// gas ssaCFGOptimized: 304311 +// gas irOptimized: 304950 +// gas ssaCFGOptimized: 304511 // test2((uint8[],uint8[2])[][1]): 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 116659 -// gas ssaCFGOptimized: 116336 +// gas irOptimized: 116747 +// gas ssaCFGOptimized: 116424 // test3((uint8[],uint8[2])[1][]): 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 187942 -// gas ssaCFGOptimized: 187645 +// gas irOptimized: 188070 +// gas ssaCFGOptimized: 187773 diff --git a/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol b/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol index 2221b031d349..3ec7e7195915 100644 --- a/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/nested_array_of_structs_memory_to_storage.sol @@ -29,11 +29,11 @@ contract C { // compileViaYul: true // ---- // test1((uint8[],uint8[2])[][]): 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -> 0x20, 2, 0x40, 0x0140, 1, 0x20, 0x60, 3, 7, 2, 1, 2, 2, 0x40, 0x0100, 0x60, 17, 19, 2, 11, 13, 0x60, 31, 37, 2, 23, 29 -// gas irOptimized: 309034 -// gas ssaCFGOptimized: 308324 +// gas irOptimized: 308854 +// gas ssaCFGOptimized: 308144 // test2((uint8[],uint8[2])[][1]): 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 0x20, 1, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 118320 -// gas ssaCFGOptimized: 117937 +// gas irOptimized: 118244 +// gas ssaCFGOptimized: 117861 // test3((uint8[],uint8[2])[1][]): 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -> 0x20, 2, 0x40, 0x0120, 0x20, 0x60, 3, 7, 2, 1, 2, 0x20, 0x60, 17, 19, 2, 11, 13 -// gas irOptimized: 190993 -// gas ssaCFGOptimized: 190491 +// gas irOptimized: 190869 +// gas ssaCFGOptimized: 190367 diff --git a/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol b/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol index 98a3eb6c97cb..90dba2d8abfd 100644 --- a/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/array/copying/nested_dynamic_array_element_calldata_to_storage.sol @@ -30,9 +30,9 @@ contract C { // compileViaYul: true // ---- // test(uint8[][][]): 0x20, 2, 0x40, 0x60, 0, 2, 0x40, 0x80, 1, 7, 2, 8, 9 -// gas irOptimized: 137891 -// gas ssaCFGOptimized: 137818 +// gas irOptimized: 137947 +// gas ssaCFGOptimized: 137874 // test2(uint8[][]): 0x20, 2, 0x40, 0x80, 1, 7, 2, 8, 9 -// gas irOptimized: 164249 +// gas irOptimized: 164305 // gas legacyOptimized: 120228 -// gas ssaCFGOptimized: 164110 +// gas ssaCFGOptimized: 164166 diff --git a/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol b/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol index 6456bf1791bb..3f699c345e49 100644 --- a/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol +++ b/test/libsolidity/semanticTests/array/copying/storage_memory_nested.sol @@ -17,7 +17,7 @@ contract C { } // ---- // f() -> 1, 2, 3, 4, 5, 6, 7 -// gas irOptimized: 206440 +// gas irOptimized: 206411 // gas legacy: 211758 -// gas legacyOptimized: 211179 -// gas ssaCFGOptimized: 206582 +// gas legacyOptimized: 210977 +// gas ssaCFGOptimized: 206483 diff --git a/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol b/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol index b2b422a6d836..db956f353e26 100644 --- a/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol +++ b/test/libsolidity/semanticTests/array/copying/storage_memory_nested_from_pointer.sol @@ -18,7 +18,7 @@ contract C { } // ---- // f() -> 1, 2, 3, 4, 5, 6, 7 -// gas irOptimized: 206440 +// gas irOptimized: 206411 // gas legacy: 211770 -// gas legacyOptimized: 211191 -// gas ssaCFGOptimized: 206582 +// gas legacyOptimized: 210989 +// gas ssaCFGOptimized: 206483 diff --git a/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol b/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol index 5b55b53e0c20..2045eb7ec415 100644 --- a/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol +++ b/test/libsolidity/semanticTests/array/copying/storage_memory_nested_struct.sol @@ -24,7 +24,7 @@ contract C { } // ---- // f() -> 11, 0x0c, 1, 0x15, 22, 4 -// gas irOptimized: 291212 +// gas irOptimized: 291340 // gas legacy: 293398 // gas legacyOptimized: 290218 -// gas ssaCFGOptimized: 291116 +// gas ssaCFGOptimized: 291244 diff --git a/test/libsolidity/semanticTests/array/create_memory_array.sol b/test/libsolidity/semanticTests/array/create_memory_array.sol index 7dcdb2d59300..eed470e874cd 100644 --- a/test/libsolidity/semanticTests/array/create_memory_array.sol +++ b/test/libsolidity/semanticTests/array/create_memory_array.sol @@ -18,7 +18,7 @@ contract C { } // ---- // f() -> "A", 8, 4, "B" -// gas irOptimized: 136664 +// gas irOptimized: 136655 // gas legacy: 121380 -// gas legacyOptimized: 115488 -// gas ssaCFGOptimized: 133210 +// gas legacyOptimized: 115462 +// gas ssaCFGOptimized: 133201 diff --git a/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol b/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol index 4719cec6b87e..834617725f25 100644 --- a/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol +++ b/test/libsolidity/semanticTests/array/delete/bytes_delete_element.sol @@ -18,5 +18,5 @@ contract c { // test1() -> true // gas irOptimized: 218420 // gas legacy: 242263 -// gas legacyOptimized: 241187 +// gas legacyOptimized: 241169 // gas ssaCFGOptimized: 218854 diff --git a/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol b/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol index cf416c16d192..52d945ae315b 100644 --- a/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol +++ b/test/libsolidity/semanticTests/array/delete/delete_storage_array_packed.sol @@ -14,6 +14,6 @@ contract C { } // ---- // f() -> 0, 0, 0 -// gas irOptimized: 88028 +// gas irOptimized: 88032 // gas legacy: 88796 -// gas legacyOptimized: 87704 +// gas legacyOptimized: 87694 diff --git a/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol b/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol index 154766dcd7b1..094869249a9e 100644 --- a/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol +++ b/test/libsolidity/semanticTests/array/fixed_arrays_as_return_type.sol @@ -18,11 +18,11 @@ contract B { } // ---- // f() -> 2, 3, 4, 5, 6, 1000, 1001, 1002, 1003, 1004 -// gas irOptimized: 59212 +// gas irOptimized: 59208 // gas irOptimized code: 56600 // gas legacy: 68001 // gas legacy code: 162000 -// gas legacyOptimized: 59997 +// gas legacyOptimized: 59989 // gas legacyOptimized code: 70600 -// gas ssaCFGOptimized: 59120 +// gas ssaCFGOptimized: 59116 // gas ssaCFGOptimized code: 56200 diff --git a/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol b/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol index cc2cc605abc3..f0a2fc43fb33 100644 --- a/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol +++ b/test/libsolidity/semanticTests/array/fixed_arrays_in_constructors.sol @@ -9,13 +9,13 @@ contract Creator { } // ---- // constructor(): 1, 2, 3, 4 -> -// gas irOptimized: 104102 -// gas irOptimized code: 22400 +// gas irOptimized: 103653 +// gas irOptimized code: 21400 // gas legacy: 115185 // gas legacy code: 59000 -// gas legacyOptimized: 104908 -// gas legacyOptimized code: 23800 -// gas ssaCFGOptimized: 103937 -// gas ssaCFGOptimized code: 20600 +// gas legacyOptimized: 104565 +// gas legacyOptimized code: 22600 +// gas ssaCFGOptimized: 103602 +// gas ssaCFGOptimized code: 20000 // r() -> 4 // ch() -> 3 diff --git a/test/libsolidity/semanticTests/array/function_array_cross_calls.sol b/test/libsolidity/semanticTests/array/function_array_cross_calls.sol index 8145097979e6..1ea4bbd939a4 100644 --- a/test/libsolidity/semanticTests/array/function_array_cross_calls.sol +++ b/test/libsolidity/semanticTests/array/function_array_cross_calls.sol @@ -42,11 +42,11 @@ contract C { } // ---- // test() -> 5, 6, 7 -// gas irOptimized: 86484 -// gas irOptimized code: 161200 +// gas irOptimized: 86711 +// gas irOptimized code: 155200 // gas legacy: 97551 // gas legacy code: 342800 -// gas legacyOptimized: 87808 -// gas legacyOptimized code: 193000 -// gas ssaCFGOptimized: 86180 -// gas ssaCFGOptimized code: 161600 +// gas legacyOptimized: 87911 +// gas legacyOptimized code: 188600 +// gas ssaCFGOptimized: 86436 +// gas ssaCFGOptimized code: 155600 diff --git a/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol b/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol index 1454e3ebe507..db6e6dc588b7 100644 --- a/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol +++ b/test/libsolidity/semanticTests/array/invalid_encoding_for_storage_byte_array.sol @@ -40,10 +40,10 @@ contract C { // copyFromStorageShort() // x() -> 0x20, 3, 0x6162630000000000000000000000000000000000000000000000000000000000 // copyFromStorageLong() -// gas irOptimized: 121092 +// gas irOptimized: 121100 // gas legacy: 121904 // gas legacyOptimized: 121393 -// gas ssaCFGOptimized: 121077 +// gas ssaCFGOptimized: 121085 // x() -> 0x20, 0x25, 0x3132333435363738393031323334353637383930313233343536373839303132, 0x3334353637000000000000000000000000000000000000000000000000000000 // copyToStorage() // x() -> 0x20, 0x25, 0x3132333435363738393031323334353637383930313233343536373839303132, 0x3334353637000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_delete.sol b/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_delete.sol index 2fdbdfedc286..e7c94adeaef8 100644 --- a/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_delete.sol +++ b/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_delete.sol @@ -69,7 +69,7 @@ contract C { // checkSlots() -> 0, 0, 0, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 0 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // fillArray() -// gas irOptimized: 197289 +// gas irOptimized: 196425 // gas legacy: 220574 // gas legacyOptimized: 206839 // gas ssaCFGOptimized: 196710 diff --git a/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_overwrite_with_long.sol b/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_overwrite_with_long.sol index ca46ecc7e0bf..23bf9c2e3c52 100644 --- a/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_overwrite_with_long.sol +++ b/test/libsolidity/semanticTests/array/long_byte_array_cleanup_after_overwrite_with_long.sol @@ -88,10 +88,10 @@ contract C { // arrayLength() -> 0 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // fillArray() -// gas irOptimized: 197352 +// gas irOptimized: 196488 // gas legacy: 220574 // gas legacyOptimized: 206839 -// gas ssaCFGOptimized: 197540 +// gas ssaCFGOptimized: 196676 // arrayLength() -> 96 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // getArrayBytes(uint256,uint256): 0, 5 -> 0x20, 5, 0x0102030405000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol b/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol index 9135bf4172e0..20882f4398dd 100644 --- a/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol +++ b/test/libsolidity/semanticTests/array/pop/byte_array_pop_long_storage_empty.sol @@ -16,8 +16,8 @@ contract c { } // ---- // test() -> true -// gas irOptimized: 138795 +// gas irOptimized: 138500 // gas legacy: 178396 -// gas legacyOptimized: 163832 -// gas ssaCFGOptimized: 139626 +// gas legacyOptimized: 163569 +// gas ssaCFGOptimized: 139100 // storageEmpty -> 1 diff --git a/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol b/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol index e6004d2d2ecc..af3b11f6818e 100644 --- a/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol +++ b/test/libsolidity/semanticTests/array/push/array_push_nested_from_calldata.sol @@ -12,7 +12,7 @@ contract C { } // ---- // f(uint120[]): 0x20, 3, 1, 2, 3 -> 1 -// gas irOptimized: 112852 +// gas irOptimized: 112833 // gas legacy: 114404 -// gas legacyOptimized: 113087 -// gas ssaCFGOptimized: 112788 +// gas legacyOptimized: 113079 +// gas ssaCFGOptimized: 112769 diff --git a/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol b/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol index e6c010230859..4bc957d86bb2 100644 --- a/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol +++ b/test/libsolidity/semanticTests/array/push/array_push_packed_array.sol @@ -13,6 +13,6 @@ contract c { } // ---- // test() -> 1, 2, 3, 4 -// gas irOptimized: 92545 +// gas irOptimized: 92505 // gas legacy: 92756 -// gas legacyOptimized: 92045 +// gas legacyOptimized: 92017 diff --git a/test/libsolidity/semanticTests/array/push/array_push_struct.sol b/test/libsolidity/semanticTests/array/push/array_push_struct.sol index 29156c756aaf..9d91d0d67375 100644 --- a/test/libsolidity/semanticTests/array/push/array_push_struct.sol +++ b/test/libsolidity/semanticTests/array/push/array_push_struct.sol @@ -20,7 +20,7 @@ contract c { } // ---- // test() -> 2, 3, 4, 5 -// gas irOptimized: 135329 +// gas irOptimized: 135361 // gas legacy: 139481 // gas legacyOptimized: 135795 -// gas ssaCFGOptimized: 135108 +// gas ssaCFGOptimized: 135140 diff --git a/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol b/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol index 42001e191aa5..f3d82fd5dd29 100644 --- a/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol +++ b/test/libsolidity/semanticTests/array/push/array_push_struct_from_calldata.sol @@ -18,5 +18,5 @@ contract c { // test((uint16,uint16,uint16[3],uint16[])): 0x20, 2, 3, 0, 0, 4, 0xC0, 4, 0, 0, 5, 0, 0 -> 2, 3, 4, 5 // gas irOptimized: 137153 // gas legacy: 142414 -// gas legacyOptimized: 137975 +// gas legacyOptimized: 137999 // gas ssaCFGOptimized: 136989 diff --git a/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol b/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol index 3efae0b1e198..f6c3c2f0dbef 100644 --- a/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol +++ b/test/libsolidity/semanticTests/array/push/byte_array_push_transition.sol @@ -17,5 +17,5 @@ contract c { // test() -> 0 // gas irOptimized: 167569 // gas legacy: 206218 -// gas legacyOptimized: 197297 +// gas legacyOptimized: 196478 // gas ssaCFGOptimized: 169902 diff --git a/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol b/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol index d929ea2b0a2c..324f24d46583 100644 --- a/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol +++ b/test/libsolidity/semanticTests/array/push/nested_bytes_push.sol @@ -13,7 +13,7 @@ contract C { } // ---- // f() -> -// gas irOptimized: 179534 +// gas irOptimized: 179507 // gas legacy: 181013 -// gas legacyOptimized: 180406 -// gas ssaCFGOptimized: 179479 +// gas legacyOptimized: 180394 +// gas ssaCFGOptimized: 179452 diff --git a/test/libsolidity/semanticTests/array/reusing_memory.sol b/test/libsolidity/semanticTests/array/reusing_memory.sol index da617572c002..7f9791fe18ae 100644 --- a/test/libsolidity/semanticTests/array/reusing_memory.sol +++ b/test/libsolidity/semanticTests/array/reusing_memory.sol @@ -24,11 +24,11 @@ contract Main { } // ---- // f(uint256): 0x34 -> 0x46bddb1178e94d7f2892ff5f366840eb658911794f2c3a44c450aa2c505186c1 -// gas irOptimized: 99552 +// gas irOptimized: 99536 // gas irOptimized code: 12400 // gas legacy: 101551 // gas legacy code: 23600 -// gas legacyOptimized: 99612 +// gas legacyOptimized: 99608 // gas legacyOptimized code: 13400 -// gas ssaCFGOptimized: 99509 +// gas ssaCFGOptimized: 99501 // gas ssaCFGOptimized code: 11000 diff --git a/test/libsolidity/semanticTests/cleanup/byte_array_to_storage_cleanup.sol b/test/libsolidity/semanticTests/cleanup/byte_array_to_storage_cleanup.sol index d5511582eb97..c209a0f4d813 100644 --- a/test/libsolidity/semanticTests/cleanup/byte_array_to_storage_cleanup.sol +++ b/test/libsolidity/semanticTests/cleanup/byte_array_to_storage_cleanup.sol @@ -28,16 +28,16 @@ contract C { // compileViaYul: also // ---- // constructor() -> -// gas irOptimized: 82586 -// gas irOptimized code: 363600 +// gas irOptimized: 82202 +// gas irOptimized code: 358800 // gas legacy: 101811 // gas legacy code: 608200 -// gas legacyOptimized: 85196 -// gas legacyOptimized code: 394800 -// gas ssaCFGOptimized: 82194 -// gas ssaCFGOptimized code: 360200 +// gas legacyOptimized: 84940 +// gas legacyOptimized code: 391600 +// gas ssaCFGOptimized: 81804 +// gas ssaCFGOptimized code: 355400 // h() -> 0x20, 0x40, 0x00, 0 // ~ emit ev(uint256[],uint256): 0x40, 0x21, 0x02, 0x00, 0x00 // g() -> 0x20, 0x40, 0, 0x00 // f(bytes): 0x20, 33, 0, -1 -> 0x20, 0x22, 0, 0xff00000000000000000000000000000000000000000000000000000000000000 -// gas irOptimized: 54117 +// gas irOptimized: 54149 diff --git a/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol b/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol index 3c019e6bac58..2faa0c396dde 100644 --- a/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol +++ b/test/libsolidity/semanticTests/constructor/arrays_in_constructors.sol @@ -24,11 +24,11 @@ contract Creator { } // ---- // f(uint256,address[]): 7, 0x40, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 -> 7, 8 -// gas irOptimized: 327784 -// gas irOptimized code: 94000 +// gas irOptimized: 327610 +// gas irOptimized code: 89800 // gas legacy: 338477 // gas legacy code: 244800 -// gas legacyOptimized: 329166 -// gas legacyOptimized code: 117000 -// gas ssaCFGOptimized: 327535 -// gas ssaCFGOptimized code: 89800 +// gas legacyOptimized: 328979 +// gas legacyOptimized code: 112200 +// gas ssaCFGOptimized: 327364 +// gas ssaCFGOptimized code: 85600 diff --git a/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol b/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol index aa4979a14744..4bc797a21ab8 100644 --- a/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol +++ b/test/libsolidity/semanticTests/constructor/bytes_in_constructors_packer.sol @@ -24,11 +24,11 @@ contract Creator { } // ---- // f(uint256,bytes): 7, 0x40, 78, "abcdefghijklmnopqrstuvwxyzabcdef", "ghijklmnopqrstuvwxyzabcdefghijkl", "mnopqrstuvwxyz" -> 7, "h" -// gas irOptimized: 169297 -// gas irOptimized code: 99600 +// gas irOptimized: 169304 +// gas irOptimized code: 97200 // gas legacy: 172946 // gas legacy code: 239800 -// gas legacyOptimized: 169823 -// gas legacyOptimized code: 118600 +// gas legacyOptimized: 169793 +// gas legacyOptimized code: 115400 // gas ssaCFGOptimized: 169268 -// gas ssaCFGOptimized code: 100600 +// gas ssaCFGOptimized code: 98200 diff --git a/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol b/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol index 4f471e4bcc6e..715b0e991b62 100644 --- a/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol +++ b/test/libsolidity/semanticTests/constructor/bytes_in_constructors_unpacker.sol @@ -8,13 +8,13 @@ contract Test { } // ---- // constructor(): 7, 0x40, 78, "abcdefghijklmnopqrstuvwxyzabcdef", "ghijklmnopqrstuvwxyzabcdefghijkl", "mnopqrstuvwxyz" -> -// gas irOptimized: 181629 +// gas irOptimized: 181405 // gas irOptimized code: 78400 // gas legacy: 195484 // gas legacy code: 109400 -// gas legacyOptimized: 181853 +// gas legacyOptimized: 181645 // gas legacyOptimized code: 71400 -// gas ssaCFGOptimized: 181424 +// gas ssaCFGOptimized: 181192 // gas ssaCFGOptimized code: 76000 // m_x() -> 7 // m_s() -> 0x20, 78, "abcdefghijklmnopqrstuvwxyzabcdef", "ghijklmnopqrstuvwxyzabcdefghijkl", "mnopqrstuvwxyz" diff --git a/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol b/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol index ae124aaaf3f4..b8a98e2fcef8 100644 --- a/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol +++ b/test/libsolidity/semanticTests/constructor/constructor_arguments_external.sol @@ -15,16 +15,15 @@ contract Main { return flag; } } -// ==== // ---- // constructor(): "abc", true -// gas irOptimized: 80174 -// gas irOptimized code: 24200 +// gas irOptimized: 80019 +// gas irOptimized code: 23800 // gas legacy: 85098 // gas legacy code: 58200 -// gas legacyOptimized: 80132 -// gas legacyOptimized code: 22800 -// gas ssaCFGOptimized: 80062 -// gas ssaCFGOptimized code: 22600 +// gas legacyOptimized: 80018 +// gas legacyOptimized code: 22400 +// gas ssaCFGOptimized: 79907 +// gas ssaCFGOptimized code: 22200 // getFlag() -> true // getName() -> "abc" diff --git a/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol b/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol index f6b983cf8716..3baddc99c5e4 100644 --- a/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol +++ b/test/libsolidity/semanticTests/constructor/constructor_static_array_argument.sol @@ -7,16 +7,15 @@ contract C { b = _b; } } -// ==== // ---- // constructor(): 1, 2, 3, 4 -> -// gas irOptimized: 148129 +// gas irOptimized: 148025 // gas irOptimized code: 23000 // gas legacy: 166201 // gas legacy code: 60400 -// gas legacyOptimized: 149177 +// gas legacyOptimized: 149125 // gas legacyOptimized code: 26200 -// gas ssaCFGOptimized: 147962 +// gas ssaCFGOptimized: 147858 // gas ssaCFGOptimized code: 21200 // a() -> 1 // b(uint256): 0 -> 2 diff --git a/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol b/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol index 5058b8592a30..f4daa3c4c9f2 100644 --- a/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol +++ b/test/libsolidity/semanticTests/constructor/no_callvalue_check.sol @@ -19,11 +19,11 @@ contract C { // EVMVersion: >=constantinople // ---- // f(), 2000 ether -> true -// gas irOptimized: 117688 +// gas irOptimized: 117712 // gas irOptimized code: 1800 // gas legacy: 117889 // gas legacy code: 4800 // gas legacyOptimized: 117761 // gas legacyOptimized code: 4800 -// gas ssaCFGOptimized: 117690 +// gas ssaCFGOptimized: 117714 // gas ssaCFGOptimized code: 1800 diff --git a/test/libsolidity/semanticTests/errors/small_error_optimization.sol b/test/libsolidity/semanticTests/errors/small_error_optimization.sol index f1315ec53200..d275b6a1da46 100644 --- a/test/libsolidity/semanticTests/errors/small_error_optimization.sol +++ b/test/libsolidity/semanticTests/errors/small_error_optimization.sol @@ -14,11 +14,11 @@ contract B { } // ---- // f() -> FAILURE, hex"92bbf6e8" -// gas irOptimized: 221918 +// gas irOptimized: 221914 // gas irOptimized code: 42800 // gas legacy: 233752 // gas legacy code: 38000 -// gas legacyOptimized: 224863 +// gas legacyOptimized: 224859 // gas legacyOptimized code: 34200 -// gas ssaCFGOptimized: 222511 +// gas ssaCFGOptimized: 222507 // gas ssaCFGOptimized code: 42000 diff --git a/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol b/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol index d779e743602f..5253e9fc192f 100644 --- a/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol +++ b/test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol @@ -13,16 +13,15 @@ contract C { d.deposit(_id); } } -// ==== // ---- // constructor() -> -// gas irOptimized: 113970 -// gas irOptimized code: 51400 +// gas irOptimized: 113632 +// gas irOptimized code: 50800 // gas legacy: 119791 // gas legacy code: 125200 -// gas legacyOptimized: 114187 -// gas legacyOptimized code: 57400 -// gas ssaCFGOptimized: 113651 -// gas ssaCFGOptimized code: 47400 +// gas legacyOptimized: 114016 +// gas legacyOptimized code: 56800 +// gas ssaCFGOptimized: 113428 +// gas ssaCFGOptimized code: 46800 // deposit(bytes32), 18 wei: 0x1234 -> // ~ emit Deposit(address,bytes32,uint256) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: #0xc06afe3a8444fc0004668591e8306bfb9968e79e, #0x1234, 0x00 diff --git a/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol b/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol index 422373e37cdd..23ac164e6822 100644 --- a/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol +++ b/test/libsolidity/semanticTests/externalContracts/FixedFeeRegistrar.sol @@ -74,19 +74,19 @@ contract FixedFeeRegistrar is Registrar { } // ---- // constructor() -// gas irOptimized: 78076 -// gas irOptimized code: 307400 +// gas irOptimized: 76371 +// gas irOptimized code: 286400 // gas legacy: 115395 // gas legacy code: 792400 -// gas legacyOptimized: 84598 -// gas legacyOptimized code: 388000 -// gas ssaCFGOptimized: 78844 -// gas ssaCFGOptimized code: 321800 +// gas legacyOptimized: 83123 +// gas legacyOptimized code: 369800 +// gas ssaCFGOptimized: 77124 +// gas ssaCFGOptimized code: 300600 // reserve(string), 69 ether: 0x20, 3, "abc" -> // ~ emit Changed(string): #0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45 -// gas irOptimized: 45741 +// gas irOptimized: 45754 // gas legacy: 46698 -// gas legacyOptimized: 45948 +// gas legacyOptimized: 45961 // owner(string): 0x20, 3, "abc" -> 0x1212121212121212121212121212120000000012 // reserve(string), 70 ether: 0x20, 3, "def" -> // ~ emit Changed(string): #0x34607c9bbfeb9c23509680f04363f298fdb0b5f9abe327304ecd1daca08cda9c diff --git a/test/libsolidity/semanticTests/externalContracts/base64.sol b/test/libsolidity/semanticTests/externalContracts/base64.sol index 5395cd184ee8..6ce0f4125512 100644 --- a/test/libsolidity/semanticTests/externalContracts/base64.sol +++ b/test/libsolidity/semanticTests/externalContracts/base64.sol @@ -33,14 +33,14 @@ contract test { // EVMVersion: >=constantinople // ---- // constructor() -// gas irOptimized: 79076 -// gas irOptimized code: 322000 +// gas irOptimized: 78730 +// gas irOptimized code: 318200 // gas legacy: 102214 // gas legacy code: 629800 -// gas legacyOptimized: 87926 -// gas legacyOptimized code: 429800 -// gas ssaCFGOptimized: 79879 -// gas ssaCFGOptimized code: 331800 +// gas legacyOptimized: 86977 +// gas legacyOptimized code: 418400 +// gas ssaCFGOptimized: 79376 +// gas ssaCFGOptimized code: 325600 // encode_inline_asm(bytes): 0x20, 0 -> 0x20, 0 // encode_inline_asm(bytes): 0x20, 1, "f" -> 0x20, 4, "Zg==" // encode_inline_asm(bytes): 0x20, 2, "fo" -> 0x20, 4, "Zm8=" @@ -56,12 +56,12 @@ contract test { // encode_no_asm(bytes): 0x20, 5, "fooba" -> 0x20, 8, "Zm9vYmE=" // encode_no_asm(bytes): 0x20, 6, "foobar" -> 0x20, 8, "Zm9vYmFy" // encode_inline_asm_large() -// gas irOptimized: 1406025 +// gas irOptimized: 1442025 // gas legacy: 1554038 -// gas legacyOptimized: 1132031 -// gas ssaCFGOptimized: 1388025 +// gas legacyOptimized: 1140031 +// gas ssaCFGOptimized: 1424025 // encode_no_asm_large() -// gas irOptimized: 3512081 +// gas irOptimized: 3485081 // gas legacy: 4600082 -// gas legacyOptimized: 2813075 +// gas legacyOptimized: 2769075 // gas ssaCFGOptimized: 3077081 diff --git a/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol b/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol index 76a6f467c024..c8f2eaac5033 100644 --- a/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol +++ b/test/libsolidity/semanticTests/externalContracts/deposit_contract.sol @@ -176,44 +176,44 @@ contract DepositContract is IDepositContract, ERC165 { } // ---- // constructor() -// gas irOptimized: 809570 -// gas irOptimized code: 558000 +// gas irOptimized: 808354 +// gas irOptimized code: 548800 // gas legacy: 920228 // gas legacy code: 1438800 -// gas legacyOptimized: 848699 -// gas legacyOptimized code: 878200 -// gas ssaCFGOptimized: 809403 -// gas ssaCFGOptimized code: 568200 +// gas legacyOptimized: 847403 +// gas legacyOptimized code: 862400 +// gas ssaCFGOptimized: 808456 +// gas ssaCFGOptimized code: 558600 // supportsInterface(bytes4): 0x0 -> 0 // supportsInterface(bytes4): 0xffffffff00000000000000000000000000000000000000000000000000000000 -> false # defined to be false by ERC-165 # // supportsInterface(bytes4): 0x01ffc9a700000000000000000000000000000000000000000000000000000000 -> true # ERC-165 id # // supportsInterface(bytes4): 0x8564090700000000000000000000000000000000000000000000000000000000 -> true # the deposit interface id # // get_deposit_root() -> 0xd70a234731285c6804c2a4f56711ddb8c82c99740f207854891028af34e27e5e -// gas irOptimized: 109178 +// gas irOptimized: 109463 // gas legacy: 142741 -// gas legacyOptimized: 117558 -// gas ssaCFGOptimized: 109652 +// gas legacyOptimized: 117531 +// gas ssaCFGOptimized: 109925 // get_deposit_count() -> 0x20, 8, 0 # TODO: check balance and logs after each deposit # // deposit(bytes,bytes,bytes,bytes32), 32 ether: 0 -> FAILURE # Empty input # // get_deposit_root() -> 0xd70a234731285c6804c2a4f56711ddb8c82c99740f207854891028af34e27e5e -// gas irOptimized: 109178 +// gas irOptimized: 109463 // gas legacy: 142741 -// gas legacyOptimized: 117558 -// gas ssaCFGOptimized: 109652 +// gas legacyOptimized: 117531 +// gas ssaCFGOptimized: 109925 // get_deposit_count() -> 0x20, 8, 0 // deposit(bytes,bytes,bytes,bytes32), 1 ether: 0x80, 0xe0, 0x120, 0xaa4a8d0b7d9077248630f1a4701ae9764e42271d7f22b7838778411857fd349e, 0x30, 0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f73292, 0x67a8811c397529dac52ae1342ba58c9500000000000000000000000000000000, 0x20, 0x00f50428677c60f997aadeab24aabf7fceaef491c96a52b463ae91f95611cf71, 0x60, 0xa29d01cc8c6296a8150e515b5995390ef841dc18948aa3e79be6d7c1851b4cbb, 0x5d6ff49fa70b9c782399506a22a85193151b9b691245cebafd2063012443c132, 0x4b6c36debaedefb7b2d71b0503ffdc00150aaffd42e63358238ec888901738b8 -> # txhash: 0x7085c586686d666e8bb6e9477a0f0b09565b2060a11f1c4209d3a52295033832 # // ~ emit DepositEvent(bytes,bytes,bytes,bytes,bytes): 0xa0, 0x0100, 0x0140, 0x0180, 0x0200, 0x30, 0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f73292, 0x67a8811c397529dac52ae1342ba58c9500000000000000000000000000000000, 0x20, 0xf50428677c60f997aadeab24aabf7fceaef491c96a52b463ae91f95611cf71, 0x08, 0xca9a3b00000000000000000000000000000000000000000000000000000000, 0x60, 0xa29d01cc8c6296a8150e515b5995390ef841dc18948aa3e79be6d7c1851b4cbb, 0x5d6ff49fa70b9c782399506a22a85193151b9b691245cebafd2063012443c132, 0x4b6c36debaedefb7b2d71b0503ffdc00150aaffd42e63358238ec888901738b8, 0x08, 0x00 // get_deposit_root() -> 0x2089653123d9c721215120b6db6738ba273bbc5228ac093b1f983badcdc8a438 -// gas irOptimized: 109174 +// gas irOptimized: 109459 // gas legacy: 142750 -// gas legacyOptimized: 117570 -// gas ssaCFGOptimized: 109645 +// gas legacyOptimized: 117543 +// gas ssaCFGOptimized: 109918 // get_deposit_count() -> 0x20, 8, 0x0100000000000000000000000000000000000000000000000000000000000000 // deposit(bytes,bytes,bytes,bytes32), 32 ether: 0x80, 0xe0, 0x120, 0xdbd986dc85ceb382708cf90a3500f500f0a393c5ece76963ac3ed72eccd2c301, 0x30, 0xb2ce0f79f90e7b3a113ca5783c65756f96c4b4673c2b5c1eb4efc22280259441, 0x06d601211e8866dc5b50dc48a244dd7c00000000000000000000000000000000, 0x20, 0x00344b6c73f71b11c56aba0d01b7d8ad83559f209d0a4101a515f6ad54c89771, 0x60, 0x945caaf82d18e78c033927d51f452ebcd76524497b91d7a11219cb3db6a1d369, 0x7595fc095ce489e46b2ef129591f2f6d079be4faaf345a02c5eb133c072e7c56, 0x0c6c3617eee66b4b878165c502357d49485326bc6b31bc96873f308c8f19c09d -> # txhash: 0x404d8e109822ce448e68f45216c12cb051b784d068fbe98317ab8e50c58304ac # // ~ emit DepositEvent(bytes,bytes,bytes,bytes,bytes): 0xa0, 0x0100, 0x0140, 0x0180, 0x0200, 0x30, 0xb2ce0f79f90e7b3a113ca5783c65756f96c4b4673c2b5c1eb4efc22280259441, 0x06d601211e8866dc5b50dc48a244dd7c00000000000000000000000000000000, 0x20, 0x344b6c73f71b11c56aba0d01b7d8ad83559f209d0a4101a515f6ad54c89771, 0x08, 0x40597307000000000000000000000000000000000000000000000000000000, 0x60, 0x945caaf82d18e78c033927d51f452ebcd76524497b91d7a11219cb3db6a1d369, 0x7595fc095ce489e46b2ef129591f2f6d079be4faaf345a02c5eb133c072e7c56, 0x0c6c3617eee66b4b878165c502357d49485326bc6b31bc96873f308c8f19c09d, 0x08, 0x0100000000000000000000000000000000000000000000000000000000000000 // get_deposit_root() -> 0x40255975859377d912c53aa853245ebd939bdd2b33a28e084babdcc1ed8238ee -// gas irOptimized: 109174 +// gas irOptimized: 109459 // gas legacy: 142750 -// gas legacyOptimized: 117570 -// gas ssaCFGOptimized: 109645 +// gas legacyOptimized: 117543 +// gas ssaCFGOptimized: 109918 // get_deposit_count() -> 0x20, 8, 0x0200000000000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol b/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol index b94076ac543e..7b74fe1b1415 100644 --- a/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol +++ b/test/libsolidity/semanticTests/externalContracts/prbmath_signed.sol @@ -48,18 +48,18 @@ contract test { } // ---- // constructor() -// gas irOptimized: 177903 -// gas irOptimized code: 1674400 +// gas irOptimized: 177819 +// gas irOptimized code: 1673800 // gas legacy: 209723 // gas legacy code: 2205000 -// gas legacyOptimized: 178012 -// gas legacyOptimized code: 1669600 -// gas ssaCFGOptimized: 175028 -// gas ssaCFGOptimized code: 1639200 +// gas legacyOptimized: 178072 +// gas legacyOptimized code: 1670200 +// gas ssaCFGOptimized: 174956 +// gas ssaCFGOptimized code: 1638600 // div(int256,int256): 3141592653589793238, 88714123 -> 35412542528203691288251815328 -// gas irOptimized: 22045 +// gas irOptimized: 22041 // gas legacy: 22736 -// gas legacyOptimized: 22264 +// gas legacyOptimized: 22260 // exp(int256): 3141592653589793238 -> 23140692632779268978 // gas irOptimized: 24452 // gas legacy: 25124 @@ -73,26 +73,26 @@ contract test { // gas legacy: 23202 // gas legacyOptimized: 22685 // log10(int256): 3141592653589793238 -> 4971498726941338506 -// gas irOptimized: 30300 +// gas irOptimized: 30292 // gas legacy: 32841 -// gas legacyOptimized: 30249 +// gas legacyOptimized: 30241 // log2(int256): 3141592653589793238 -> 1651496129472318782 // gas irOptimized: 28566 // gas legacy: 30979 // gas legacyOptimized: 28357 // mul(int256,int256): 3141592653589793238, 88714123 -> 278703637 -// gas irOptimized: 22147 +// gas irOptimized: 22143 // gas legacy: 22775 -// gas legacyOptimized: 22288 +// gas legacyOptimized: 22284 // pow(int256,uint256): 3141592653589793238, 5 -> 306019684785281453040 -// gas irOptimized: 22488 +// gas irOptimized: 22484 // gas legacy: 23453 -// gas legacyOptimized: 22921 +// gas legacyOptimized: 22917 // sqrt(int256): 3141592653589793238 -> 1772453850905516027 // gas irOptimized: 22458 // gas legacy: 22784 // gas legacyOptimized: 22420 // benchmark(int256): 3141592653589793238 -> 998882724338592125, 1000000000000000000, 1000000000000000000 -// gas irOptimized: 34893 +// gas irOptimized: 34845 // gas legacy: 35244 -// gas legacyOptimized: 33996 +// gas legacyOptimized: 33948 diff --git a/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol b/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol index 64643b327720..61b951af3450 100644 --- a/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol +++ b/test/libsolidity/semanticTests/externalContracts/ramanujan_pi.sol @@ -33,15 +33,15 @@ contract test { } // ---- // constructor() -// gas irOptimized: 77816 -// gas irOptimized code: 307600 +// gas irOptimized: 77366 +// gas irOptimized code: 302200 // gas legacy: 92110 // gas legacy code: 523600 -// gas legacyOptimized: 82667 -// gas legacyOptimized code: 369200 -// gas ssaCFGOptimized: 77956 -// gas ssaCFGOptimized code: 313400 +// gas legacyOptimized: 82523 +// gas legacyOptimized code: 367400 +// gas ssaCFGOptimized: 77512 +// gas ssaCFGOptimized code: 308000 // prb_pi() -> 3141592656369545286 -// gas irOptimized: 55036 +// gas irOptimized: 54848 // gas legacy: 100657 -// gas legacyOptimized: 74311 +// gas legacyOptimized: 74147 diff --git a/test/libsolidity/semanticTests/externalContracts/snark.sol b/test/libsolidity/semanticTests/externalContracts/snark.sol index 13ec1ef5380a..0f1c52e0bc10 100644 --- a/test/libsolidity/semanticTests/externalContracts/snark.sol +++ b/test/libsolidity/semanticTests/externalContracts/snark.sol @@ -292,13 +292,13 @@ contract Test { // f() -> true // g() -> true // pair() -> true -// gas irOptimized: 275229 +// gas irOptimized: 275733 // gas legacy: 293579 -// gas legacyOptimized: 276313 -// gas ssaCFGOptimized: 275795 +// gas legacyOptimized: 276345 +// gas ssaCFGOptimized: 276299 // verifyTx() -> true // ~ emit Verified(string): 0x20, 0x16, "Successfully verified." -// gas irOptimized: 818076 +// gas irOptimized: 820852 // gas legacy: 904397 -// gas legacyOptimized: 816770 -// gas ssaCFGOptimized: 820130 +// gas legacyOptimized: 817006 +// gas ssaCFGOptimized: 822906 diff --git a/test/libsolidity/semanticTests/externalContracts/strings.sol b/test/libsolidity/semanticTests/externalContracts/strings.sol index 76f5001563ec..d4cd91b26e81 100644 --- a/test/libsolidity/semanticTests/externalContracts/strings.sol +++ b/test/libsolidity/semanticTests/externalContracts/strings.sol @@ -49,32 +49,32 @@ contract test { } // ---- // constructor() -// gas irOptimized: 95303 -// gas irOptimized code: 520000 +// gas irOptimized: 94602 +// gas irOptimized code: 511400 // gas legacy: 126346 // gas legacy code: 932600 -// gas legacyOptimized: 102639 -// gas legacyOptimized code: 612400 -// gas ssaCFGOptimized: 96128 -// gas ssaCFGOptimized code: 531800 +// gas legacyOptimized: 101904 +// gas legacyOptimized code: 603600 +// gas ssaCFGOptimized: 95451 +// gas ssaCFGOptimized code: 523200 // toSlice(string): 0x20, 11, "hello world" -> 11, 0xa0 -// gas irOptimized: 22646 +// gas irOptimized: 22694 // gas legacy: 23168 -// gas legacyOptimized: 22488 +// gas legacyOptimized: 22512 // roundtrip(string): 0x20, 11, "hello world" -> 0x20, 11, "hello world" -// gas irOptimized: 23225 +// gas irOptimized: 23289 // gas legacy: 23674 -// gas legacyOptimized: 22991 +// gas legacyOptimized: 23023 // utf8len(string): 0x20, 16, "\xf0\x9f\x98\x83\xf0\x9f\x98\x83\xf0\x9f\x98\x83\xf0\x9f\x98\x83" -> 4 # Input: "😃😃😃😃" # -// gas irOptimized: 23956 +// gas irOptimized: 23996 // gas legacy: 25621 -// gas legacyOptimized: 24096 +// gas legacyOptimized: 24120 // multiconcat(string,uint256): 0x40, 3, 11, "hello world" -> 0x20, 0x58, 0x68656c6c6f20776f726c6468656c6c6f20776f726c6468656c6c6f20776f726c, 0x6468656c6c6f20776f726c6468656c6c6f20776f726c6468656c6c6f20776f72, 49027192869463622675296414541903001712009715982962058146354235762728281047040 # concatenating 3 times # -// gas irOptimized: 27630 +// gas irOptimized: 27814 // gas legacy: 30778 -// gas legacyOptimized: 27519 +// gas legacyOptimized: 27575 // benchmark(string,bytes32): 0x40, 0x0842021, 8, "solidity" -> 0x2020 -// gas irOptimized: 1976778 +// gas irOptimized: 1977370 // gas legacy: 4234020 -// gas legacyOptimized: 2318668 -// gas ssaCFGOptimized: 1882325 +// gas legacyOptimized: 2318804 +// gas ssaCFGOptimized: 1882917 diff --git a/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol b/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol index 03c8ab5d5b63..ac2dfa5efe59 100644 --- a/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol +++ b/test/libsolidity/semanticTests/functionCall/creation_function_call_with_args.sol @@ -15,12 +15,12 @@ contract D { } // ---- // constructor(): 2 -> -// gas irOptimized: 138930 -// gas irOptimized code: 53800 +// gas irOptimized: 138483 +// gas irOptimized code: 53200 // gas legacy: 145569 // gas legacy code: 95600 -// gas legacyOptimized: 138297 -// gas legacyOptimized code: 54600 -// gas ssaCFGOptimized: 138527 -// gas ssaCFGOptimized code: 49400 +// gas legacyOptimized: 138078 +// gas legacyOptimized code: 53400 +// gas ssaCFGOptimized: 138200 +// gas ssaCFGOptimized code: 48800 // f() -> 2 diff --git a/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol b/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol index 4856eb9605f2..154c23529c9a 100644 --- a/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol +++ b/test/libsolidity/semanticTests/functionCall/creation_function_call_with_salt.sol @@ -17,12 +17,12 @@ contract D { // EVMVersion: >=constantinople // ---- // constructor(): 2 -> -// gas irOptimized: 139112 -// gas irOptimized code: 53800 +// gas irOptimized: 138659 +// gas irOptimized code: 53200 // gas legacy: 145935 // gas legacy code: 95600 -// gas legacyOptimized: 138529 -// gas legacyOptimized code: 54600 -// gas ssaCFGOptimized: 138684 -// gas ssaCFGOptimized code: 49400 +// gas legacyOptimized: 138310 +// gas legacyOptimized code: 53400 +// gas ssaCFGOptimized: 138357 +// gas ssaCFGOptimized code: 48800 // f() -> 2 diff --git a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol index 7f7f75bbb207..b933a93d15ad 100644 --- a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol +++ b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting.sol @@ -20,17 +20,16 @@ contract C { return 1 + c; } } -// ==== // ---- // constructor(), 1 ether -> -// gas irOptimized: 88853 -// gas irOptimized code: 164400 +// gas irOptimized: 88320 +// gas irOptimized code: 158400 // gas legacy: 102721 // gas legacy code: 334400 -// gas legacyOptimized: 91499 -// gas legacyOptimized code: 196400 -// gas ssaCFGOptimized: 87601 -// gas ssaCFGOptimized code: 151000 +// gas legacyOptimized: 90894 +// gas legacyOptimized code: 189800 +// gas ssaCFGOptimized: 87043 +// gas ssaCFGOptimized code: 145000 // f(uint256): 0 -> FAILURE // f(uint256): 1 -> FAILURE // f(uint256): 2 -> FAILURE diff --git a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol index 2b15f3beb4df..b207319187fc 100644 --- a/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol +++ b/test/libsolidity/semanticTests/functionCall/external_call_to_nonexisting_debugstrings.sol @@ -25,14 +25,14 @@ contract C { // revertStrings: debug // ---- // constructor(), 1 ether -> -// gas irOptimized: 98698 -// gas irOptimized code: 284200 +// gas irOptimized: 98141 +// gas irOptimized code: 278200 // gas legacy: 123258 // gas legacy code: 682400 -// gas legacyOptimized: 106969 -// gas legacyOptimized code: 386400 -// gas ssaCFGOptimized: 97826 -// gas ssaCFGOptimized code: 274200 +// gas legacyOptimized: 106364 +// gas legacyOptimized code: 379800 +// gas ssaCFGOptimized: 97268 +// gas ssaCFGOptimized code: 268200 // f(uint256): 0 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code" // f(uint256): 1 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code" // f(uint256): 2 -> FAILURE, hex"08c379a0", 0x20, 37, "Target contract does not contain", " code" diff --git a/test/libsolidity/semanticTests/functionCall/failed_create.sol b/test/libsolidity/semanticTests/functionCall/failed_create.sol index 54e9015ebbe4..e3ee0f66879d 100644 --- a/test/libsolidity/semanticTests/functionCall/failed_create.sol +++ b/test/libsolidity/semanticTests/functionCall/failed_create.sol @@ -17,14 +17,14 @@ contract C { // EVMVersion: >=constantinople // ---- // constructor(), 20 wei -// gas irOptimized: 59688 -// gas irOptimized code: 81800 +// gas irOptimized: 59496 +// gas irOptimized code: 79400 // gas legacy: 64468 // gas legacy code: 145400 // gas legacyOptimized: 60443 // gas legacyOptimized code: 91200 -// gas ssaCFGOptimized: 59603 -// gas ssaCFGOptimized code: 80800 +// gas ssaCFGOptimized: 59411 +// gas ssaCFGOptimized code: 78400 // f(uint256): 20 -> // x() -> 1 // f(uint256): 20 -> FAILURE diff --git a/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol b/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol index 3a0bc8d1eb36..eefddd3e795b 100644 --- a/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol +++ b/test/libsolidity/semanticTests/functionCall/gas_and_value_basic.sol @@ -36,14 +36,14 @@ contract test { } // ---- // constructor(), 20 wei -> -// gas irOptimized: 120218 -// gas irOptimized code: 132000 +// gas irOptimized: 119784 +// gas irOptimized code: 130200 // gas legacy: 130583 // gas legacy code: 261200 -// gas legacyOptimized: 121069 -// gas legacyOptimized code: 147000 -// gas ssaCFGOptimized: 119466 -// gas ssaCFGOptimized code: 122800 +// gas legacyOptimized: 120706 +// gas legacyOptimized code: 144000 +// gas ssaCFGOptimized: 119129 +// gas ssaCFGOptimized code: 121000 // sendAmount(uint256): 5 -> 5 // outOfGas() -> FAILURE # call to helper should not succeed but amount should be transferred anyway # // checkState() -> false, 15 diff --git a/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol b/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol index 8eeaf7b51cad..50b654924e77 100644 --- a/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol +++ b/test/libsolidity/semanticTests/functionCall/send_zero_ether.sol @@ -15,10 +15,10 @@ contract Main { } // ---- // constructor(), 20 wei -> -// gas irOptimized: 56314 -// gas irOptimized code: 37400 +// gas irOptimized: 56282 +// gas irOptimized code: 37000 // gas legacy: 57555 // gas legacy code: 53000 -// gas legacyOptimized: 56463 -// gas legacyOptimized code: 39600 +// gas legacyOptimized: 56415 +// gas legacyOptimized code: 39000 // s() -> true diff --git a/test/libsolidity/semanticTests/functionTypes/store_function.sol b/test/libsolidity/semanticTests/functionTypes/store_function.sol index 904bc705f725..7156382d5b32 100644 --- a/test/libsolidity/semanticTests/functionTypes/store_function.sol +++ b/test/libsolidity/semanticTests/functionTypes/store_function.sol @@ -25,9 +25,9 @@ contract C { } // ---- // t() -> 9 -// gas irOptimized: 77300 +// gas irOptimized: 77346 // gas irOptimized code: 19000 // gas legacy: 79492 // gas legacy code: 69600 -// gas legacyOptimized: 77587 +// gas legacyOptimized: 77580 // gas legacyOptimized code: 28600 diff --git a/test/libsolidity/semanticTests/immutable/immutable_tag_too_large_bug.sol b/test/libsolidity/semanticTests/immutable/immutable_tag_too_large_bug.sol index fc7a41f7a1b8..db8ea235fac5 100644 --- a/test/libsolidity/semanticTests/immutable/immutable_tag_too_large_bug.sol +++ b/test/libsolidity/semanticTests/immutable/immutable_tag_too_large_bug.sol @@ -41,10 +41,10 @@ contract C { // compileViaYul: true // ---- // constructor() -> -// gas irOptimized: 73171 -// gas irOptimized code: 291200 +// gas irOptimized: 73019 +// gas irOptimized code: 290000 // gas legacy: 83499 // gas legacy code: 408800 -// gas ssaCFGOptimized: 72146 -// gas ssaCFGOptimized code: 272200 +// gas ssaCFGOptimized: 72066 +// gas ssaCFGOptimized code: 271600 // f() -> -1, 1 diff --git a/test/libsolidity/semanticTests/immutable/multi_creation.sol b/test/libsolidity/semanticTests/immutable/multi_creation.sol index b111c34a06ca..d1d5002ba6fb 100644 --- a/test/libsolidity/semanticTests/immutable/multi_creation.sol +++ b/test/libsolidity/semanticTests/immutable/multi_creation.sol @@ -29,13 +29,13 @@ contract C { // EVMVersion: >=constantinople // ---- // f() -> 3, 7, 5 -// gas irOptimized: 86892 +// gas irOptimized: 86916 // gas irOptimized code: 37200 // gas legacy: 87839 // gas legacy code: 60800 -// gas legacyOptimized: 86870 +// gas legacyOptimized: 86862 // gas legacyOptimized code: 37200 -// gas ssaCFGOptimized: 86821 +// gas ssaCFGOptimized: 86845 // gas ssaCFGOptimized code: 34400 // x() -> 7 // y() -> 5 diff --git a/test/libsolidity/semanticTests/immutable/use_scratch.sol b/test/libsolidity/semanticTests/immutable/use_scratch.sol index 270791c97375..05e7b0319ca2 100644 --- a/test/libsolidity/semanticTests/immutable/use_scratch.sol +++ b/test/libsolidity/semanticTests/immutable/use_scratch.sol @@ -15,13 +15,13 @@ contract C { } // ---- // constructor(): 3 -> -// gas irOptimized: 81194 +// gas irOptimized: 81138 // gas irOptimized code: 42400 // gas legacy: 88244 // gas legacy code: 109400 // gas legacyOptimized: 81858 // gas legacyOptimized code: 55800 -// gas ssaCFGOptimized: 81069 +// gas ssaCFGOptimized: 81013 // gas ssaCFGOptimized code: 40600 // f() -> 84, 23 // m(uint256): 3 -> 7 diff --git a/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol b/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol index f339b52445a4..7eef9a368d40 100644 --- a/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol +++ b/test/libsolidity/semanticTests/inheritance/address_overload_resolution.sol @@ -22,12 +22,12 @@ contract D { // EVMVersion: >=constantinople // ---- // f() -> 1 -// gas irOptimized: 54014 +// gas irOptimized: 54026 // gas irOptimized code: 20200 // gas legacy: 54553 // gas legacy code: 57800 // g() -> 5 -// gas irOptimized: 54042 +// gas irOptimized: 54054 // gas irOptimized code: 20200 // gas legacy: 55090 // gas legacy code: 57800 diff --git a/test/libsolidity/semanticTests/inheritance/constructor_with_params.sol b/test/libsolidity/semanticTests/inheritance/constructor_with_params.sol index 4db2cb513f2a..8f1adc78d8a9 100644 --- a/test/libsolidity/semanticTests/inheritance/constructor_with_params.sol +++ b/test/libsolidity/semanticTests/inheritance/constructor_with_params.sol @@ -9,11 +9,11 @@ contract C { } // ---- // constructor(): 2, 0 -> -// gas irOptimized: 81170 +// gas irOptimized: 81118 // gas irOptimized code: 20200 // gas legacy: 83613 // gas legacy code: 32000 -// gas ssaCFGOptimized: 81033 +// gas ssaCFGOptimized: 80981 // gas ssaCFGOptimized code: 18600 // i() -> 2 // k() -> 0 diff --git a/test/libsolidity/semanticTests/inheritance/constructor_with_params_diamond_inheritance.sol b/test/libsolidity/semanticTests/inheritance/constructor_with_params_diamond_inheritance.sol index fb9dc07c2c5e..fc4c432604aa 100644 --- a/test/libsolidity/semanticTests/inheritance/constructor_with_params_diamond_inheritance.sol +++ b/test/libsolidity/semanticTests/inheritance/constructor_with_params_diamond_inheritance.sol @@ -21,13 +21,13 @@ contract D is B, C { } // ---- // constructor(): 2, 0 -> -// gas irOptimized: 124350 +// gas irOptimized: 124298 // gas irOptimized code: 27600 // gas legacy: 128222 // gas legacy code: 40400 // gas legacyOptimized: 123920 // gas legacyOptimized code: 20600 -// gas ssaCFGOptimized: 124253 +// gas ssaCFGOptimized: 124201 // gas ssaCFGOptimized code: 26200 // i() -> 2 // j() -> 2 diff --git a/test/libsolidity/semanticTests/inheritance/constructor_with_params_inheritance.sol b/test/libsolidity/semanticTests/inheritance/constructor_with_params_inheritance.sol index 349f44bc37ac..2eb47b9f5e3f 100644 --- a/test/libsolidity/semanticTests/inheritance/constructor_with_params_inheritance.sol +++ b/test/libsolidity/semanticTests/inheritance/constructor_with_params_inheritance.sol @@ -12,13 +12,13 @@ contract D is C { } // ---- // constructor(): 2, 0 -> -// gas irOptimized: 101581 +// gas irOptimized: 101529 // gas irOptimized code: 20200 // gas legacy: 105192 // gas legacy code: 32000 // gas legacyOptimized: 101503 // gas legacyOptimized code: 17000 -// gas ssaCFGOptimized: 101462 +// gas ssaCFGOptimized: 101410 // gas ssaCFGOptimized code: 18600 // i() -> 2 // k() -> 1 diff --git a/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol b/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol index e9013d6f52be..67909700e849 100644 --- a/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol +++ b/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_calldata_interface.sol @@ -22,7 +22,7 @@ contract B { } // ---- // g() -> 42 -// gas irOptimized: 54536 +// gas irOptimized: 54548 // gas irOptimized code: 24800 // gas legacy: 55868 // gas legacy code: 66600 diff --git a/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol b/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol index 36ed3706243a..ab48ad44232d 100644 --- a/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol +++ b/test/libsolidity/semanticTests/inheritance/inherited_function_calldata_memory_interface.sol @@ -22,9 +22,9 @@ contract B { } // ---- // g() -> 42 -// gas irOptimized: 54828 -// gas irOptimized code: 42000 +// gas irOptimized: 54859 +// gas irOptimized code: 39600 // gas legacy: 56839 // gas legacy code: 123600 -// gas legacyOptimized: 55001 -// gas legacyOptimized code: 60600 +// gas legacyOptimized: 55013 +// gas legacyOptimized code: 58200 diff --git a/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol b/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol index b8dd90097f3e..e266eb557425 100644 --- a/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol +++ b/test/libsolidity/semanticTests/inheritance/value_for_constructor.sol @@ -39,14 +39,14 @@ contract Main { } // ---- // constructor(), 22 wei -> -// gas irOptimized: 143864 -// gas irOptimized code: 118000 +// gas irOptimized: 143147 +// gas irOptimized code: 114200 // gas legacy: 156599 // gas legacy code: 236400 -// gas legacyOptimized: 143592 -// gas legacyOptimized code: 118000 -// gas ssaCFGOptimized: 143472 -// gas ssaCFGOptimized code: 112600 +// gas legacyOptimized: 142987 +// gas legacyOptimized code: 113000 +// gas ssaCFGOptimized: 142864 +// gas ssaCFGOptimized code: 108800 // getFlag() -> true // getName() -> "abc" // getBalances() -> 12, 10 diff --git a/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol b/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol index 6be1b0e95e11..3a2b68a64703 100644 --- a/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol +++ b/test/libsolidity/semanticTests/inlineAssembly/transient_storage_selfdestruct.sol @@ -40,17 +40,17 @@ contract D { // EVMVersion: >=cancun // ---- // constructor() -> -// gas irOptimized: 127596 -// gas irOptimized code: 221000 +// gas irOptimized: 126804 +// gas irOptimized code: 214800 // gas legacy: 149480 // gas legacy code: 501200 -// gas legacyOptimized: 125846 -// gas legacyOptimized code: 203400 -// gas ssaCFGOptimized: 126096 -// gas ssaCFGOptimized code: 203200 +// gas legacyOptimized: 125119 +// gas legacyOptimized code: 196000 +// gas ssaCFGOptimized: 125418 +// gas ssaCFGOptimized code: 197000 // destroy() -> // createAndDestroy() -> // gas legacy: 67048 // gas legacy code: 92600 -// gas legacyOptimized: 65677 -// gas legacyOptimized code: 39400 +// gas legacyOptimized: 65640 +// gas legacyOptimized code: 38200 diff --git a/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol b/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol index 548325069256..0b33212520b4 100644 --- a/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol +++ b/test/libsolidity/semanticTests/libraries/internal_types_in_library.sol @@ -24,5 +24,5 @@ contract Test { // f() -> 4, 0x11 // gas irOptimized: 111419 // gas legacy: 132930 -// gas legacyOptimized: 118020 +// gas legacyOptimized: 118006 // gas ssaCFGOptimized: 111707 diff --git a/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol b/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol index b901cab0351a..4ffe2ebbd6e4 100644 --- a/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol +++ b/test/libsolidity/semanticTests/operators/userDefined/operator_making_pure_external_call.sol @@ -54,16 +54,16 @@ contract C { // EVMVersion: >=constantinople // ---- // testMul(int32,int32): 42, 10 -> 420 -// gas irOptimized: 54784 +// gas irOptimized: 54796 // gas irOptimized code: 40600 // gas legacy: 57117 // gas legacy code: 127000 -// gas legacyOptimized: 55246 +// gas legacyOptimized: 55242 // gas legacyOptimized code: 68400 // testInc(int32): 42 -> 43 -// gas irOptimized: 54621 +// gas irOptimized: 54633 // gas irOptimized code: 40600 // gas legacy: 56378 // gas legacy code: 127000 -// gas legacyOptimized: 54943 +// gas legacyOptimized: 54939 // gas legacyOptimized code: 68400 diff --git a/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol b/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol index 15501b3fc24e..c0ef486b934f 100644 --- a/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol +++ b/test/libsolidity/semanticTests/operators/userDefined/operator_making_view_external_call.sol @@ -60,16 +60,16 @@ contract C { // EVMVersion: >=constantinople // ---- // testMul(int32,int32): 42, 10 -> 420 -// gas irOptimized: 54784 +// gas irOptimized: 54796 // gas irOptimized code: 40600 // gas legacy: 57117 // gas legacy code: 127000 -// gas legacyOptimized: 55246 +// gas legacyOptimized: 55242 // gas legacyOptimized code: 68400 // testInc(int32): 42 -> 43 -// gas irOptimized: 54621 +// gas irOptimized: 54633 // gas irOptimized code: 40600 // gas legacy: 56378 // gas legacy code: 127000 -// gas legacyOptimized: 54943 +// gas legacyOptimized: 54939 // gas legacyOptimized code: 68400 diff --git a/test/libsolidity/semanticTests/saltedCreate/salted_create_with_value.sol b/test/libsolidity/semanticTests/saltedCreate/salted_create_with_value.sol index 6bf3064724d3..dc785a9b52c4 100644 --- a/test/libsolidity/semanticTests/saltedCreate/salted_create_with_value.sol +++ b/test/libsolidity/semanticTests/saltedCreate/salted_create_with_value.sol @@ -21,11 +21,11 @@ contract A { // EVMVersion: >=constantinople // ---- // f(), 10 ether -> 3007, 3008, 3009 -// gas irOptimized: 187022 +// gas irOptimized: 187046 // gas irOptimized code: 67200 // gas legacy: 190858 // gas legacy code: 190200 -// gas legacyOptimized: 187256 +// gas legacyOptimized: 187244 // gas legacyOptimized code: 92400 -// gas ssaCFGOptimized: 186904 +// gas ssaCFGOptimized: 186928 // gas ssaCFGOptimized code: 62400 diff --git a/test/libsolidity/semanticTests/smoke/constructor.sol b/test/libsolidity/semanticTests/smoke/constructor.sol index bba5fedf64d8..2e092538fd0c 100644 --- a/test/libsolidity/semanticTests/smoke/constructor.sol +++ b/test/libsolidity/semanticTests/smoke/constructor.sol @@ -12,13 +12,13 @@ contract C { } // ---- // constructor(), 2 wei: 3 -> -// gas irOptimized: 78996 +// gas irOptimized: 78944 // gas irOptimized code: 25400 // gas legacy: 83055 // gas legacy code: 65200 // gas legacyOptimized: 78898 // gas legacyOptimized code: 27800 -// gas ssaCFGOptimized: 78848 +// gas ssaCFGOptimized: 78796 // gas ssaCFGOptimized code: 23800 // state() -> 3 // balance() -> 2 diff --git a/test/libsolidity/semanticTests/storage/delete_overlapping_transient_before_storage_array_partial_assignment_same_base_type.sol b/test/libsolidity/semanticTests/storage/delete_overlapping_transient_before_storage_array_partial_assignment_same_base_type.sol index 602ceb4923dc..d11a5eb54a70 100644 --- a/test/libsolidity/semanticTests/storage/delete_overlapping_transient_before_storage_array_partial_assignment_same_base_type.sol +++ b/test/libsolidity/semanticTests/storage/delete_overlapping_transient_before_storage_array_partial_assignment_same_base_type.sol @@ -21,8 +21,8 @@ contract C { // EVMVersion: >=cancun // ---- // setAndClear() -> -// gas irOptimized: 124683 +// gas irOptimized: 124696 // gas legacy: 127807 // gas legacyOptimized: 124828 -// gas ssaCFGOptimized: 124676 +// gas ssaCFGOptimized: 124688 // getLarge() -> 10, 20, 0, 0 diff --git a/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol b/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol index baa37c5ab7d5..b930c0d133f2 100644 --- a/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol +++ b/test/libsolidity/semanticTests/storage/empty_nonempty_empty.sol @@ -22,13 +22,13 @@ contract Test { // set(bytes): 0x20, 0 // storageEmpty -> 1 // set(bytes): 0x20, 66, "12345678901234567890123456789012", "12345678901234567890123456789012", "12" -// gas irOptimized: 111820 +// gas irOptimized: 111852 // gas legacy: 112734 -// gas legacyOptimized: 112089 -// gas ssaCFGOptimized: 111796 +// gas legacyOptimized: 112121 +// gas ssaCFGOptimized: 111828 // storageEmpty -> 0 // set(bytes): 0x20, 3, "abc" -// gas irOptimized: 33989 +// gas irOptimized: 34015 // storageEmpty -> 0 // set(bytes): 0x20, 0 // storageEmpty -> 1 diff --git a/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol b/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol index 5f563511f97e..6f869199d8a4 100644 --- a/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol +++ b/test/libsolidity/semanticTests/storage/packed_storage_structs_bytes.sol @@ -42,7 +42,7 @@ contract C { } // ---- // test() -> true -// gas irOptimized: 132633 +// gas irOptimized: 132549 // gas legacy: 136010 -// gas legacyOptimized: 133478 -// gas ssaCFGOptimized: 132572 +// gas legacyOptimized: 133394 +// gas ssaCFGOptimized: 132502 diff --git a/test/libsolidity/semanticTests/storage/static_array_copy_cleanup.sol b/test/libsolidity/semanticTests/storage/static_array_copy_cleanup.sol index c75fb7ccba22..a49cafa9f813 100644 --- a/test/libsolidity/semanticTests/storage/static_array_copy_cleanup.sol +++ b/test/libsolidity/semanticTests/storage/static_array_copy_cleanup.sol @@ -68,17 +68,17 @@ contract C { // getSourceAsUint() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // getDestAsUint() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // fillSource() -// gas irOptimized: 135018 +// gas irOptimized: 134923 // gas legacy: 146851 -// gas legacyOptimized: 137549 -// gas ssaCFGOptimized: 137978 +// gas legacyOptimized: 137374 +// gas ssaCFGOptimized: 137728 // canary() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // getSourceAsUint() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 // fillDest() -// gas irOptimized: 248706 +// gas irOptimized: 248516 // gas legacy: 272468 -// gas legacyOptimized: 253871 -// gas ssaCFGOptimized: 254266 +// gas legacyOptimized: 253521 +// gas ssaCFGOptimized: 253886 // canary() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // getSourceAsUint() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 // getDestAsUint() -> 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_array_and_partial_assignment_with_layout.sol b/test/libsolidity/semanticTests/storage/storage_boundary_array_and_partial_assignment_with_layout.sol index 5efc36958869..8b83ad7cf942 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_array_and_partial_assignment_with_layout.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_array_and_partial_assignment_with_layout.sol @@ -51,6 +51,6 @@ contract C layout at 2**256 - 5 { // x() -> 14, 15, 16, 17, 18, 19, 20, 0, 0, 0 // clearArray() // x() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 44183 +// gas irOptimized: 44199 // gas legacy: 46007 // gas legacyOptimized: 43907 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_array_partial_assignment.sol b/test/libsolidity/semanticTests/storage/storage_boundary_array_partial_assignment.sol index 699c7d4429d8..7481267ff1ac 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_array_partial_assignment.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_array_partial_assignment.sol @@ -37,6 +37,6 @@ contract C { // x() -> 11, 12, 13, 14, 15, 16, 17, 0, 0, 0 // partialAssignArrayBeforeStorageBoundary() // x() -> 21, 22, 23, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 44183 +// gas irOptimized: 44199 // gas legacy: 46012 // gas legacyOptimized: 43907 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_delete_overflow_bug.sol b/test/libsolidity/semanticTests/storage/storage_boundary_delete_overflow_bug.sol index 6ce0c3d7ad97..98f66c579795 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_delete_overflow_bug.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_delete_overflow_bug.sol @@ -51,37 +51,37 @@ contract C { // ---- // x() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 604108 +// gas irOptimized: 604104 // gas legacy: 644983 -// gas legacyOptimized: 598016 -// gas ssaCFGOptimized: 602576 +// gas legacyOptimized: 598012 +// gas ssaCFGOptimized: 602572 // fillArray() -// gas irOptimized: 5782148 +// gas irOptimized: 5781128 // gas legacy: 6044562 -// gas legacyOptimized: 5853893 -// gas ssaCFGOptimized: 5784445 +// gas legacyOptimized: 5852873 +// gas ssaCFGOptimized: 5783425 // x() -> 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 -// gas irOptimized: 604108 +// gas irOptimized: 604104 // gas legacy: 644983 -// gas legacyOptimized: 598016 -// gas ssaCFGOptimized: 602576 +// gas legacyOptimized: 598012 +// gas ssaCFGOptimized: 602572 // partialAssignArray() -// gas irOptimized: 1067376 +// gas irOptimized: 1067372 // gas legacy: 1177356 -// gas legacyOptimized: 1068067 -// gas ssaCFGOptimized: 1067374 +// gas legacyOptimized: 1068064 +// gas ssaCFGOptimized: 1067371 // x() -> 11, 22, 33, 44, 55, 66, 77, 88, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 604108 +// gas irOptimized: 604104 // gas legacy: 644983 -// gas legacyOptimized: 598016 -// gas ssaCFGOptimized: 602576 +// gas legacyOptimized: 598012 +// gas ssaCFGOptimized: 602572 // clearArray() -// gas irOptimized: 580378 +// gas irOptimized: 580374 // gas legacy: 582973 -// gas legacyOptimized: 581299 -// gas ssaCFGOptimized: 580387 +// gas legacyOptimized: 581295 +// gas ssaCFGOptimized: 580383 // x() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 604108 +// gas irOptimized: 604104 // gas legacy: 644983 -// gas legacyOptimized: 598016 -// gas ssaCFGOptimized: 602576 +// gas legacyOptimized: 598012 +// gas ssaCFGOptimized: 602572 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_packed_array.sol b/test/libsolidity/semanticTests/storage/storage_boundary_packed_array.sol index e77da7c06412..60aba3fa6b63 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_packed_array.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_packed_array.sol @@ -23,14 +23,14 @@ contract C { // ---- // x() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // fillArray() -// gas irOptimized: 254227 +// gas irOptimized: 254859 // gas legacy: 258712 -// gas legacyOptimized: 257258 -// gas ssaCFGOptimized: 254343 +// gas legacyOptimized: 258514 +// gas ssaCFGOptimized: 255287 // x() -> 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 // clearArray() // gas irOptimized: 57426 // x() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 48087 +// gas irOptimized: 48663 // gas legacy: 64080 -// gas legacyOptimized: 56602 +// gas legacyOptimized: 57562 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_mixed_types.sol b/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_mixed_types.sol index 2aed15fbe473..a9e707f39c0a 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_mixed_types.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_mixed_types.sol @@ -98,92 +98,92 @@ contract C { // ---- // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 113169 +// gas irOptimized: 113425 // gas legacy: 120742 -// gas legacyOptimized: 112518 -// gas ssaCFGOptimized: 113202 +// gas legacyOptimized: 112698 +// gas ssaCFGOptimized: 113458 // destArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 113078 +// gas irOptimized: 113334 // gas legacy: 120738 -// gas legacyOptimized: 112505 -// gas ssaCFGOptimized: 113111 +// gas legacyOptimized: 112685 +// gas ssaCFGOptimized: 113367 // fillBoundaryArray() -// gas irOptimized: 912522 +// gas irOptimized: 912592 // gas legacy: 930728 -// gas legacyOptimized: 916628 -// gas ssaCFGOptimized: 915317 +// gas legacyOptimized: 916638 +// gas ssaCFGOptimized: 915617 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, true, 6, 7, 8, 9, true, 11, 12, 13, 14, true, 16, 17, 18, 19, true, 21, 22, 23, 24, true, 26, 27, 28, 29, true, 31, 32, 33, 34, true, 36, 37, 38, 39, true, 41, 42, 43, 44, true, 46, 47, 48, 49, true -// gas irOptimized: 113169 +// gas irOptimized: 113425 // gas legacy: 120742 -// gas legacyOptimized: 112518 -// gas ssaCFGOptimized: 113202 +// gas legacyOptimized: 112698 +// gas ssaCFGOptimized: 113458 // destArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 113078 +// gas irOptimized: 113334 // gas legacy: 120738 -// gas legacyOptimized: 112505 -// gas ssaCFGOptimized: 113111 +// gas legacyOptimized: 112685 +// gas ssaCFGOptimized: 113367 // copyFromBoundary() -// gas irOptimized: 994579 +// gas irOptimized: 994519 // gas legacy: 1023407 -// gas legacyOptimized: 994746 -// gas ssaCFGOptimized: 996228 +// gas legacyOptimized: 994726 +// gas ssaCFGOptimized: 996188 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, true, 6, 7, 8, 9, true, 11, 12, 13, 14, true, 16, 17, 18, 19, true, 21, 22, 23, 24, true, 26, 27, 28, 29, true, 31, 32, 33, 34, true, 36, 37, 38, 39, true, 41, 42, 43, 44, true, 46, 47, 48, 49, true -// gas irOptimized: 113169 +// gas irOptimized: 113425 // gas legacy: 120742 -// gas legacyOptimized: 112518 -// gas ssaCFGOptimized: 113202 +// gas legacyOptimized: 112698 +// gas ssaCFGOptimized: 113458 // destArray() -> 1, 2, 3, 4, true, 6, 7, 8, 9, true, 11, 12, 13, 14, true, 16, 17, 18, 19, true, 21, 22, 23, 24, true, 26, 27, 28, 29, true, 31, 32, 33, 34, true, 36, 37, 38, 39, true, 41, 42, 43, 44, true, 46, 47, 48, 49, true -// gas irOptimized: 113078 +// gas irOptimized: 113334 // gas legacy: 120738 -// gas legacyOptimized: 112505 -// gas ssaCFGOptimized: 113111 +// gas legacyOptimized: 112685 +// gas ssaCFGOptimized: 113367 // fillDestArray() -// gas irOptimized: 200426 +// gas irOptimized: 200496 // gas legacy: 218746 -// gas legacyOptimized: 204648 -// gas ssaCFGOptimized: 203221 +// gas legacyOptimized: 204658 +// gas ssaCFGOptimized: 203431 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, true, 6, 7, 8, 9, true, 11, 12, 13, 14, true, 16, 17, 18, 19, true, 21, 22, 23, 24, true, 26, 27, 28, 29, true, 31, 32, 33, 34, true, 36, 37, 38, 39, true, 41, 42, 43, 44, true, 46, 47, 48, 49, true -// gas irOptimized: 113169 +// gas irOptimized: 113425 // gas legacy: 120742 -// gas legacyOptimized: 112518 -// gas ssaCFGOptimized: 113202 +// gas legacyOptimized: 112698 +// gas ssaCFGOptimized: 113458 // destArray() -> 51, 52, 53, 54, true, 56, 57, 58, 59, true, 61, 62, 63, 64, true, 66, 67, 68, 69, true, 71, 72, 73, 74, true, 76, 77, 78, 79, true, 81, 82, 83, 84, true, 86, 87, 88, 89, true, 91, 92, 93, 94, true, 96, 97, 98, 99, true -// gas irOptimized: 113078 +// gas irOptimized: 113334 // gas legacy: 120738 -// gas legacyOptimized: 112505 -// gas ssaCFGOptimized: 113111 +// gas legacyOptimized: 112685 +// gas ssaCFGOptimized: 113367 // copyToBoundary() -// gas irOptimized: 282623 +// gas irOptimized: 282563 // gas legacy: 311362 -// gas legacyOptimized: 282712 -// gas ssaCFGOptimized: 284272 +// gas legacyOptimized: 282692 +// gas ssaCFGOptimized: 284232 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 51, 52, 53, 54, true, 56, 57, 58, 59, true, 61, 62, 63, 64, true, 66, 67, 68, 69, true, 71, 72, 73, 74, true, 76, 77, 78, 79, true, 81, 82, 83, 84, true, 86, 87, 88, 89, true, 91, 92, 93, 94, true, 96, 97, 98, 99, true -// gas irOptimized: 113169 +// gas irOptimized: 113425 // gas legacy: 120742 -// gas legacyOptimized: 112518 -// gas ssaCFGOptimized: 113202 +// gas legacyOptimized: 112698 +// gas ssaCFGOptimized: 113458 // destArray() -> 51, 52, 53, 54, true, 56, 57, 58, 59, true, 61, 62, 63, 64, true, 66, 67, 68, 69, true, 71, 72, 73, 74, true, 76, 77, 78, 79, true, 81, 82, 83, 84, true, 86, 87, 88, 89, true, 91, 92, 93, 94, true, 96, 97, 98, 99, true -// gas irOptimized: 113078 +// gas irOptimized: 113334 // gas legacy: 120738 -// gas legacyOptimized: 112505 -// gas ssaCFGOptimized: 113111 +// gas legacyOptimized: 112685 +// gas ssaCFGOptimized: 113367 // deleteBoundaryArray() // gas irOptimized: 177968 // gas legacy: 180995 -// gas legacyOptimized: 178182 +// gas legacyOptimized: 178126 // gas ssaCFGOptimized: 177963 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -// gas irOptimized: 113169 +// gas irOptimized: 113425 // gas legacy: 120742 -// gas legacyOptimized: 112518 -// gas ssaCFGOptimized: 113202 +// gas legacyOptimized: 112698 +// gas ssaCFGOptimized: 113458 // destArray() -> 51, 52, 53, 54, true, 56, 57, 58, 59, true, 61, 62, 63, 64, true, 66, 67, 68, 69, true, 71, 72, 73, 74, true, 76, 77, 78, 79, true, 81, 82, 83, 84, true, 86, 87, 88, 89, true, 91, 92, 93, 94, true, 96, 97, 98, 99, true -// gas irOptimized: 113078 +// gas irOptimized: 113334 // gas legacy: 120738 -// gas legacyOptimized: 112505 -// gas ssaCFGOptimized: 113111 +// gas legacyOptimized: 112685 +// gas ssaCFGOptimized: 113367 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_multislot.sol b/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_multislot.sol index ce4a30c1e799..68ddc1babe86 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_multislot.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_multislot.sol @@ -92,10 +92,10 @@ contract C { // boundaryArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // destArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // fillBoundaryArray() -// gas irOptimized: 688719 +// gas irOptimized: 688799 // gas legacy: 700075 // gas legacyOptimized: 691605 -// gas ssaCFGOptimized: 688794 +// gas ssaCFGOptimized: 688874 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 // destArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 @@ -108,10 +108,10 @@ contract C { // boundaryArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 // destArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 // fillDestArray() -// gas irOptimized: 175623 +// gas irOptimized: 175703 // gas legacy: 187093 // gas legacyOptimized: 178625 -// gas ssaCFGOptimized: 175698 +// gas ssaCFGOptimized: 175778 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 // destArray() -> 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 diff --git a/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_packed.sol b/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_packed.sol index 13c4634fb1ad..ceb3fc111453 100644 --- a/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_packed.sol +++ b/test/libsolidity/semanticTests/storage/storage_boundary_struct_array_packed.sol @@ -96,18 +96,18 @@ contract C { // boundaryArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // destArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // fillBoundaryArray() -// gas irOptimized: 248990 +// gas irOptimized: 248800 // gas legacy: 272856 -// gas legacyOptimized: 253856 -// gas ssaCFGOptimized: 254545 +// gas legacyOptimized: 253506 +// gas ssaCFGOptimized: 254165 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 // destArray() -> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // copyFromBoundary() -// gas irOptimized: 274279 +// gas irOptimized: 274179 // gas legacy: 298927 -// gas legacyOptimized: 272256 -// gas ssaCFGOptimized: 275618 +// gas legacyOptimized: 272076 +// gas ssaCFGOptimized: 275358 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 // destArray() -> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 @@ -118,10 +118,10 @@ contract C { // destArray() -> 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 // gas legacy: 59729 // copyToBoundary() -// gas irOptimized: 103323 +// gas irOptimized: 103223 // gas legacy: 127882 -// gas legacyOptimized: 101222 -// gas ssaCFGOptimized: 104662 +// gas legacyOptimized: 101042 +// gas ssaCFGOptimized: 104402 // canaryValue() -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // boundaryArray() -> 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 // destArray() -> 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 diff --git a/test/libsolidity/semanticTests/storageLayoutSpecifier/constructor.sol b/test/libsolidity/semanticTests/storageLayoutSpecifier/constructor.sol index 466d5e2632a8..f72ce8b1a972 100644 --- a/test/libsolidity/semanticTests/storageLayoutSpecifier/constructor.sol +++ b/test/libsolidity/semanticTests/storageLayoutSpecifier/constructor.sol @@ -18,13 +18,13 @@ contract C is B layout at 7 { } // ---- // constructor(): 1, 2, 3 -// gas irOptimized: 104178 +// gas irOptimized: 104118 // gas irOptimized code: 30000 // gas legacy: 114749 // gas legacy code: 71400 // gas legacyOptimized: 106296 // gas legacyOptimized code: 31400 -// gas ssaCFGOptimized: 103990 +// gas ssaCFGOptimized: 103914 // gas ssaCFGOptimized code: 28600 // x() -> 2 // y() -> 4 diff --git a/test/libsolidity/semanticTests/storageLayoutSpecifier/storage_reference_array.sol b/test/libsolidity/semanticTests/storageLayoutSpecifier/storage_reference_array.sol index 657402fc0ae3..37cb8c7b7612 100644 --- a/test/libsolidity/semanticTests/storageLayoutSpecifier/storage_reference_array.sol +++ b/test/libsolidity/semanticTests/storageLayoutSpecifier/storage_reference_array.sol @@ -14,9 +14,9 @@ contract C layout at 42 { } // ---- // initUsingReference() -> -// gas irOptimized: 273556 +// gas irOptimized: 273564 // gas legacy: 274795 // gas legacyOptimized: 271954 -// gas ssaCFGOptimized: 273507 +// gas ssaCFGOptimized: 273515 // array(uint256): 0 -> 1 // array(uint256): 9 -> 10 diff --git a/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol b/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol index 5a4d1fa3ba9f..9c8ed0c955e7 100644 --- a/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol +++ b/test/libsolidity/semanticTests/structs/conversion/recursive_storage_memory.sol @@ -23,7 +23,7 @@ contract CopyTest { } // ---- // run() -> 2, 23, 42 -// gas irOptimized: 192828 +// gas irOptimized: 194468 // gas legacy: 185730 // gas legacyOptimized: 184457 -// gas ssaCFGOptimized: 191813 +// gas ssaCFGOptimized: 193453 diff --git a/test/libsolidity/semanticTests/structs/copy_from_mapping.sol b/test/libsolidity/semanticTests/structs/copy_from_mapping.sol index 7f1529b44bdf..a41344f746d1 100644 --- a/test/libsolidity/semanticTests/structs/copy_from_mapping.sol +++ b/test/libsolidity/semanticTests/structs/copy_from_mapping.sol @@ -36,9 +36,9 @@ contract C { } // ---- // to_state() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 121282 +// gas irOptimized: 121330 // gas legacy: 125480 // gas legacyOptimized: 121695 -// gas ssaCFGOptimized: 121244 +// gas ssaCFGOptimized: 121292 // to_storage() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 // to_memory() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 diff --git a/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol b/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol index 8fc7b6676af9..1467dc2d9f93 100644 --- a/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol +++ b/test/libsolidity/semanticTests/structs/copy_substructures_from_mapping.sol @@ -44,9 +44,9 @@ contract C { } // ---- // to_state() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 121454 +// gas irOptimized: 121502 // gas legacy: 125617 // gas legacyOptimized: 121699 -// gas ssaCFGOptimized: 121385 +// gas ssaCFGOptimized: 121433 // to_storage() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 // to_memory() -> 0x20, 0x60, 0xa0, 7, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 diff --git a/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol b/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol index a2473409b1ea..586bc59e320b 100644 --- a/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol +++ b/test/libsolidity/semanticTests/structs/copy_substructures_to_mapping.sol @@ -52,17 +52,17 @@ contract C { } // ---- // from_memory() -> 0x20, 0x60, 0xa0, 0x15, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 122720 +// gas irOptimized: 122792 // gas legacy: 125558 -// gas legacyOptimized: 123322 -// gas ssaCFGOptimized: 122615 +// gas legacyOptimized: 123338 +// gas ssaCFGOptimized: 122687 // from_state() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 121424 +// gas irOptimized: 121472 // gas legacy: 125693 -// gas legacyOptimized: 121804 -// gas ssaCFGOptimized: 121405 +// gas legacyOptimized: 121820 +// gas ssaCFGOptimized: 121453 // from_calldata((bytes,uint16[],uint16)): 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -> 0x20, 0x60, 0xa0, 0x15, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 114852 +// gas irOptimized: 114908 // gas legacy: 117950 -// gas legacyOptimized: 115526 -// gas ssaCFGOptimized: 114687 +// gas legacyOptimized: 115566 +// gas ssaCFGOptimized: 114743 diff --git a/test/libsolidity/semanticTests/structs/copy_to_mapping.sol b/test/libsolidity/semanticTests/structs/copy_to_mapping.sol index 3e26c5417b67..814452fdd423 100644 --- a/test/libsolidity/semanticTests/structs/copy_to_mapping.sol +++ b/test/libsolidity/semanticTests/structs/copy_to_mapping.sol @@ -45,22 +45,22 @@ contract C { } // ---- // from_state() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 121515 +// gas irOptimized: 121563 // gas legacy: 125554 -// gas legacyOptimized: 121747 -// gas ssaCFGOptimized: 121454 +// gas legacyOptimized: 121763 +// gas ssaCFGOptimized: 121502 // from_storage() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 121559 +// gas irOptimized: 121607 // gas legacy: 125612 -// gas legacyOptimized: 121799 -// gas ssaCFGOptimized: 121498 +// gas legacyOptimized: 121815 +// gas ssaCFGOptimized: 121546 // from_memory() -> 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 122740 +// gas irOptimized: 122812 // gas legacy: 125423 -// gas legacyOptimized: 123323 -// gas ssaCFGOptimized: 122605 +// gas legacyOptimized: 123339 +// gas ssaCFGOptimized: 122677 // from_calldata((bytes,uint16[],uint16)): 0x20, 0x60, 0xa0, 21, 3, 0x666F6F0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -> 0x20, 0x60, 0xa0, 21, 3, 0x666f6f0000000000000000000000000000000000000000000000000000000000, 2, 13, 14 -// gas irOptimized: 114824 +// gas irOptimized: 114880 // gas legacy: 118207 -// gas legacyOptimized: 115327 -// gas ssaCFGOptimized: 114694 +// gas legacyOptimized: 115359 +// gas ssaCFGOptimized: 114750 diff --git a/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol b/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol index e2fbdeb5f495..8aaafa013e95 100644 --- a/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol +++ b/test/libsolidity/semanticTests/structs/struct_containing_bytes_copy_and_delete.sol @@ -23,19 +23,19 @@ contract c { // ---- // storageEmpty -> 1 // set(uint256,bytes,uint256): 12, 0x60, 13, 33, "12345678901234567890123456789012", "3" -> true -// gas irOptimized: 133557 +// gas irOptimized: 133573 // gas legacy: 134624 -// gas legacyOptimized: 133857 -// gas ssaCFGOptimized: 133546 +// gas legacyOptimized: 133881 +// gas ssaCFGOptimized: 133562 // test(uint256): 32 -> "3" // storageEmpty -> 0 // copy() -> true // storageEmpty -> 1 // set(uint256,bytes,uint256): 12, 0x60, 13, 33, "12345678901234567890123456789012", "3" -> true -// gas irOptimized: 133557 +// gas irOptimized: 133573 // gas legacy: 134624 -// gas legacyOptimized: 133857 -// gas ssaCFGOptimized: 133546 +// gas legacyOptimized: 133881 +// gas ssaCFGOptimized: 133562 // storageEmpty -> 0 // del() -> true // storageEmpty -> 1 diff --git a/test/libsolidity/semanticTests/structs/struct_copy_calldata_to_storage_nested_dynamic_array_v2.sol b/test/libsolidity/semanticTests/structs/struct_copy_calldata_to_storage_nested_dynamic_array_v2.sol index 98a312f3ecb0..2a5812bfb435 100644 --- a/test/libsolidity/semanticTests/structs/struct_copy_calldata_to_storage_nested_dynamic_array_v2.sol +++ b/test/libsolidity/semanticTests/structs/struct_copy_calldata_to_storage_nested_dynamic_array_v2.sol @@ -16,7 +16,7 @@ contract C { } // ---- // f(uint32,(uint128,uint256[][2],uint32)): 55, 0x40, 77, 0x60, 88, 0x40, 0x40, 2, 1, 2 -> 55, 77, 1, 2, 88 -// gas irOptimized: 202902 +// gas irOptimized: 202949 // gas legacy: 207376 -// gas legacyOptimized: 203583 -// gas ssaCFGOptimized: 202897 +// gas legacyOptimized: 203632 +// gas ssaCFGOptimized: 202941 diff --git a/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol b/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol index 12cbf0799e04..8b346ef99f72 100644 --- a/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol +++ b/test/libsolidity/semanticTests/structs/struct_delete_storage_nested_small.sol @@ -33,4 +33,4 @@ contract C { // compileViaYul: true // ---- // f() -> 0, 0, 0 -// gas irOptimized: 93835 +// gas irOptimized: 93819 diff --git a/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol b/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol index 514fec2f0668..ab929a3529e3 100644 --- a/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol +++ b/test/libsolidity/semanticTests/structs/struct_delete_storage_with_array.sol @@ -44,10 +44,10 @@ contract C { // f() -> // gas irOptimized: 113388 // gas legacy: 113583 -// gas legacyOptimized: 113119 +// gas legacyOptimized: 113096 // gas ssaCFGOptimized: 113395 // g() -> -// gas irOptimized: 118768 +// gas irOptimized: 118759 // gas legacy: 118761 -// gas legacyOptimized: 118203 -// gas ssaCFGOptimized: 118775 +// gas legacyOptimized: 118189 +// gas ssaCFGOptimized: 118765 diff --git a/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol b/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol index 4efc8c90e419..b59f0ee99547 100644 --- a/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol +++ b/test/libsolidity/semanticTests/structs/struct_memory_to_storage_function_ptr.sol @@ -28,7 +28,7 @@ contract C { } // ---- // f() -> 42, 23, 34, 42, 42 -// gas irOptimized: 110682 +// gas irOptimized: 110730 // gas legacy: 111990 -// gas legacyOptimized: 110546 -// gas ssaCFGOptimized: 110678 +// gas legacyOptimized: 110531 +// gas ssaCFGOptimized: 110737 diff --git a/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol b/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol index 40ee506b1a61..5a4758a74444 100644 --- a/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol +++ b/test/libsolidity/semanticTests/types/mapping/copy_from_mapping_to_mapping.sol @@ -29,7 +29,7 @@ contract C { } // ---- // f() -> 0x20, 7, 8, 9, 0xa0, 13, 2, 0x40, 0xa0, 2, 3, 4, 2, 3, 4 -// gas irOptimized: 197102 +// gas irOptimized: 197182 // gas legacy: 205706 // gas legacyOptimized: 196739 -// gas ssaCFGOptimized: 196903 +// gas ssaCFGOptimized: 196983 diff --git a/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol b/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol index 3347b1017e0b..79af12691e0a 100644 --- a/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol +++ b/test/libsolidity/semanticTests/userDefinedValueType/calldata.sol @@ -49,15 +49,15 @@ contract C { } // ---- // test_f() -> true -// gas irOptimized: 122114 +// gas irOptimized: 122074 // gas legacy: 126159 -// gas legacyOptimized: 122742 -// gas ssaCFGOptimized: 122136 +// gas legacyOptimized: 122674 +// gas ssaCFGOptimized: 122096 // test_g() -> true -// gas irOptimized: 106248 +// gas irOptimized: 106176 // gas legacy: 111821 -// gas legacyOptimized: 106591 -// gas ssaCFGOptimized: 106242 +// gas legacyOptimized: 106467 +// gas ssaCFGOptimized: 106170 // addresses(uint256): 0 -> 0x18 // addresses(uint256): 1 -> 0x19 // addresses(uint256): 3 -> 0x1b diff --git a/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol b/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol index 0815a2da7ace..b7b2a5ed99fa 100644 --- a/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol +++ b/test/libsolidity/semanticTests/userDefinedValueType/calldata_to_storage.sol @@ -23,19 +23,19 @@ contract C { // ---- // s() -> 0, 0, 0x00, 0 // f((uint8,uint16,bytes2,uint8)): 1, 0xff, "ab", 15 -> -// gas irOptimized: 44237 +// gas irOptimized: 44230 // gas legacy: 47154 -// gas legacyOptimized: 44982 +// gas legacyOptimized: 44975 // s() -> 1, 0xff, 0x6162000000000000000000000000000000000000000000000000000000000000, 15 // g(uint16[]): 0x20, 3, 1, 2, 3 -> 0x20, 3, 1, 2, 3 -// gas irOptimized: 68578 +// gas irOptimized: 68610 // gas legacy: 71400 -// gas legacyOptimized: 69139 +// gas legacyOptimized: 69163 // small(uint256): 0 -> 1 // small(uint256): 1 -> 2 // h(bytes2[]): 0x20, 3, "ab", "cd", "ef" -> 0x20, 3, "ab", "cd", "ef" -// gas irOptimized: 68635 +// gas irOptimized: 68604 // gas legacy: 71231 -// gas legacyOptimized: 69289 +// gas legacyOptimized: 69259 // l(uint256): 0 -> 0x6162000000000000000000000000000000000000000000000000000000000000 // l(uint256): 1 -> 0x6364000000000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol b/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol index 23cb720ade00..bd36ce4e52fa 100644 --- a/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol +++ b/test/libsolidity/semanticTests/userDefinedValueType/erc20.sol @@ -113,38 +113,38 @@ contract ERC20 { // ---- // constructor() // ~ emit Transfer(address,address,uint256): #0x00, #0x1212121212121212121212121212120000000012, 0x14 -// gas irOptimized: 121322 -// gas irOptimized code: 234600 +// gas irOptimized: 120852 +// gas irOptimized code: 228800 // gas legacy: 163350 // gas legacy code: 671400 -// gas legacyOptimized: 127464 -// gas legacyOptimized code: 285400 -// gas ssaCFGOptimized: 121536 -// gas ssaCFGOptimized code: 237200 +// gas legacyOptimized: 126678 +// gas legacyOptimized code: 277600 +// gas ssaCFGOptimized: 120932 +// gas ssaCFGOptimized code: 229800 // totalSupply() -> 20 // gas irOptimized: 23334 // gas legacy: 23645 // gas legacyOptimized: 23367 // transfer(address,uint256): 2, 5 -> true // ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x05 -// gas irOptimized: 50997 +// gas irOptimized: 50985 // gas legacy: 52323 -// gas legacyOptimized: 51380 +// gas legacyOptimized: 51360 // decreaseAllowance(address,uint256): 2, 0 -> true // ~ emit Approval(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x00 -// gas irOptimized: 26054 +// gas irOptimized: 26038 // gas legacy: 27165 -// gas legacyOptimized: 26320 +// gas legacyOptimized: 26300 // decreaseAllowance(address,uint256): 2, 1 -> FAILURE, hex"4e487b71", 0x11 -// gas irOptimized: 23954 +// gas irOptimized: 23946 // gas legacy: 24500 -// gas legacyOptimized: 24076 +// gas legacyOptimized: 24068 // transfer(address,uint256): 2, 14 -> true // ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x0e -// gas irOptimized: 33897 +// gas irOptimized: 33885 // gas legacy: 35223 -// gas legacyOptimized: 34280 +// gas legacyOptimized: 34260 // transfer(address,uint256): 2, 2 -> FAILURE, hex"4e487b71", 0x11 -// gas irOptimized: 23990 +// gas irOptimized: 23978 // gas legacy: 24483 -// gas legacyOptimized: 24072 +// gas legacyOptimized: 24060 diff --git a/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol b/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol index 6e07e74e9f71..ee91cdde4635 100644 --- a/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol +++ b/test/libsolidity/semanticTests/userDefinedValueType/memory_to_storage.sol @@ -23,19 +23,19 @@ contract C { // ---- // s() -> 0, 0, 0x00, 0 // f((uint8,uint16,bytes2,uint8)): 1, 0xff, "ab", 15 -> -// gas irOptimized: 44360 +// gas irOptimized: 44361 // gas legacy: 46189 -// gas legacyOptimized: 44673 +// gas legacyOptimized: 44674 // s() -> 1, 0xff, 0x6162000000000000000000000000000000000000000000000000000000000000, 15 // g(uint16[]): 0x20, 3, 1, 2, 3 -> 0x20, 3, 1, 2, 3 -// gas irOptimized: 68898 +// gas irOptimized: 68938 // gas legacy: 72336 -// gas legacyOptimized: 69607 +// gas legacyOptimized: 69639 // small(uint256): 0 -> 1 // small(uint256): 1 -> 2 // h(bytes2[]): 0x20, 3, "ab", "cd", "ef" -> 0x20, 3, "ab", "cd", "ef" -// gas irOptimized: 68937 +// gas irOptimized: 68914 // gas legacy: 72167 -// gas legacyOptimized: 69802 +// gas legacyOptimized: 69759 // l(uint256): 0 -> 0x6162000000000000000000000000000000000000000000000000000000000000 // l(uint256): 1 -> 0x6364000000000000000000000000000000000000000000000000000000000000 diff --git a/test/libsolidity/semanticTests/various/address_code.sol b/test/libsolidity/semanticTests/various/address_code.sol index d21f28c0727c..8f53ca60e7fa 100644 --- a/test/libsolidity/semanticTests/various/address_code.sol +++ b/test/libsolidity/semanticTests/various/address_code.sol @@ -14,13 +14,13 @@ contract C { } // ---- // constructor() -> -// gas irOptimized: 70924 +// gas irOptimized: 70768 // gas irOptimized code: 94600 // gas legacy: 82688 // gas legacy code: 153800 -// gas legacyOptimized: 69675 +// gas legacyOptimized: 69571 // gas legacyOptimized code: 79200 -// gas ssaCFGOptimized: 71073 +// gas ssaCFGOptimized: 70917 // gas ssaCFGOptimized code: 92000 // initCode() -> 0x20, 0 // f() -> true diff --git a/test/libsolidity/semanticTests/various/create_calldata.sol b/test/libsolidity/semanticTests/various/create_calldata.sol index dc3570a65d07..6e3f71314265 100644 --- a/test/libsolidity/semanticTests/various/create_calldata.sol +++ b/test/libsolidity/semanticTests/various/create_calldata.sol @@ -8,12 +8,12 @@ contract C { } // ---- // constructor(): 42 -> -// gas irOptimized: 68387 +// gas irOptimized: 68271 // gas irOptimized code: 69000 // gas legacy: 78348 // gas legacy code: 90200 -// gas legacyOptimized: 68548 +// gas legacyOptimized: 68496 // gas legacyOptimized code: 64600 -// gas ssaCFGOptimized: 68186 +// gas ssaCFGOptimized: 68070 // gas ssaCFGOptimized code: 66800 // s() -> 0x20, 0 diff --git a/test/libsolidity/semanticTests/various/destructuring_assignment.sol b/test/libsolidity/semanticTests/various/destructuring_assignment.sol index 74df91b23a19..4c899cfb51de 100644 --- a/test/libsolidity/semanticTests/various/destructuring_assignment.sol +++ b/test/libsolidity/semanticTests/various/destructuring_assignment.sol @@ -33,7 +33,7 @@ contract C { } // ---- // f(bytes): 0x20, 0x5, "abcde" -> 0 -// gas irOptimized: 242037 +// gas irOptimized: 242100 // gas legacy: 246685 -// gas legacyOptimized: 242396 -// gas ssaCFGOptimized: 241846 +// gas legacyOptimized: 242431 +// gas ssaCFGOptimized: 241909 diff --git a/test/libsolidity/semanticTests/various/different_call_type_transient.sol b/test/libsolidity/semanticTests/various/different_call_type_transient.sol index 9aa78f007130..4aa565992735 100644 --- a/test/libsolidity/semanticTests/various/different_call_type_transient.sol +++ b/test/libsolidity/semanticTests/various/different_call_type_transient.sol @@ -46,7 +46,7 @@ contract Test { // testDelegate() -> 7, 0 // testCall() -> 0, 8 // testStatic() -> false -// gas irOptimized: 96900694 +// gas irOptimized: 96900693 // gas legacy: 96901136 -// gas legacyOptimized: 96900725 -// gas ssaCFGOptimized: 96900673 +// gas legacyOptimized: 96900724 +// gas ssaCFGOptimized: 96900672 diff --git a/test/libsolidity/semanticTests/various/erc20.sol b/test/libsolidity/semanticTests/various/erc20.sol index e68abd8864e6..736e9014d5f9 100644 --- a/test/libsolidity/semanticTests/various/erc20.sol +++ b/test/libsolidity/semanticTests/various/erc20.sol @@ -96,38 +96,38 @@ contract ERC20 { // ---- // constructor() // ~ emit Transfer(address,address,uint256): #0x00, #0x1212121212121212121212121212120000000012, 0x14 -// gas irOptimized: 121632 -// gas irOptimized code: 236800 +// gas irOptimized: 121168 +// gas irOptimized code: 231000 // gas legacy: 159957 // gas legacy code: 647600 -// gas legacyOptimized: 126934 -// gas legacyOptimized code: 282000 -// gas ssaCFGOptimized: 122072 -// gas ssaCFGOptimized code: 241600 +// gas legacyOptimized: 126106 +// gas legacyOptimized code: 274200 +// gas ssaCFGOptimized: 121426 +// gas ssaCFGOptimized code: 233600 // totalSupply() -> 20 // gas irOptimized: 23334 // gas legacy: 23519 // gas legacyOptimized: 23367 // transfer(address,uint256): 2, 5 -> true // ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x05 -// gas irOptimized: 51054 +// gas irOptimized: 51042 // gas legacy: 52073 -// gas legacyOptimized: 51298 +// gas legacyOptimized: 51278 // decreaseAllowance(address,uint256): 2, 0 -> true // ~ emit Approval(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x00 -// gas irOptimized: 26087 +// gas irOptimized: 26071 // gas legacy: 26977 -// gas legacyOptimized: 26279 +// gas legacyOptimized: 26259 // decreaseAllowance(address,uint256): 2, 1 -> FAILURE, hex"4e487b71", 0x11 -// gas irOptimized: 23981 +// gas irOptimized: 23973 // gas legacy: 24462 -// gas legacyOptimized: 24056 +// gas legacyOptimized: 24048 // transfer(address,uint256): 2, 14 -> true // ~ emit Transfer(address,address,uint256): #0x1212121212121212121212121212120000000012, #0x02, 0x0e -// gas irOptimized: 33954 +// gas irOptimized: 33942 // gas legacy: 34973 -// gas legacyOptimized: 34198 +// gas legacyOptimized: 34178 // transfer(address,uint256): 2, 2 -> FAILURE, hex"4e487b71", 0x11 -// gas irOptimized: 24020 +// gas irOptimized: 24008 // gas legacy: 24445 -// gas legacyOptimized: 24052 +// gas legacyOptimized: 24040 diff --git a/test/libsolidity/semanticTests/various/many_subassemblies.sol b/test/libsolidity/semanticTests/various/many_subassemblies.sol index dcbebafb6bed..cf9a5157c316 100644 --- a/test/libsolidity/semanticTests/various/many_subassemblies.sol +++ b/test/libsolidity/semanticTests/various/many_subassemblies.sol @@ -32,11 +32,11 @@ contract D { // EVMVersion: >=constantinople // ---- // run() -> -// gas irOptimized: 375192 +// gas irOptimized: 375280 // gas irOptimized code: 6600 // gas legacy: 375404 // gas legacy code: 17600 // gas legacyOptimized: 375464 // gas legacyOptimized code: 17600 -// gas ssaCFGOptimized: 375134 +// gas ssaCFGOptimized: 375222 // gas ssaCFGOptimized code: 6600 diff --git a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol index 62d4efa01130..61029913359c 100644 --- a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol +++ b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun.sol @@ -64,14 +64,14 @@ contract D { // EVMVersion: >=cancun // ---- // constructor(), 1 ether -> -// gas irOptimized: 67028 -// gas irOptimized code: 175400 +// gas irOptimized: 66075 +// gas irOptimized code: 163800 // gas legacy: 76227 // gas legacy code: 298200 -// gas legacyOptimized: 66516 -// gas legacyOptimized code: 168000 -// gas ssaCFGOptimized: 66800 -// gas ssaCFGOptimized code: 172400 +// gas legacyOptimized: 66074 +// gas legacyOptimized code: 162400 +// gas ssaCFGOptimized: 65854 +// gas ssaCFGOptimized code: 160800 // exists() -> false // test_create_and_terminate() -> // exists() -> false diff --git a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol index ffdd66e1e694..de0b34077d66 100644 --- a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol +++ b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_multiple_beneficiaries.sol @@ -35,27 +35,27 @@ contract D { // EVMVersion: >=cancun // ---- // constructor(), 2 ether -> -// gas irOptimized: 108104 -// gas irOptimized code: 119200 +// gas irOptimized: 107406 +// gas irOptimized code: 111600 // gas legacy: 120439 // gas legacy code: 253800 -// gas legacyOptimized: 109015 -// gas legacyOptimized code: 130800 -// gas ssaCFGOptimized: 107820 -// gas ssaCFGOptimized code: 115800 +// gas legacyOptimized: 108382 +// gas legacyOptimized code: 124000 +// gas ssaCFGOptimized: 107139 +// gas ssaCFGOptimized code: 108200 // balance: 0x1111111111111111111111111111111111111111 -> 0 // balance: 0x2222222222222222222222222222222222222222 -> 0 // balance -> 2000000000000000000 // exists() -> false // test_deploy_and_terminate_twice() -> -// gas irOptimized: 121395 -// gas irOptimized code: 14000 +// gas irOptimized: 121364 +// gas irOptimized code: 13400 // gas legacy: 122386 // gas legacy code: 43200 -// gas legacyOptimized: 121596 -// gas legacyOptimized code: 22800 -// gas ssaCFGOptimized: 121361 -// gas ssaCFGOptimized code: 12400 +// gas legacyOptimized: 121545 +// gas legacyOptimized code: 21600 +// gas ssaCFGOptimized: 121327 +// gas ssaCFGOptimized code: 11800 // exists() -> false // balance: 0x1111111111111111111111111111111111111111 -> 1000000000000000000 // balance: 0x2222222222222222222222222222222222222222 -> 0 diff --git a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol index 091aa86f65b2..860f26a23ad0 100644 --- a/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol +++ b/test/libsolidity/semanticTests/various/selfdestruct_post_cancun_redeploy.sol @@ -82,24 +82,24 @@ contract D { // EVMVersion: >=cancun // ---- // constructor(), 1 ether -> -// gas irOptimized: 132974 -// gas irOptimized code: 293800 +// gas irOptimized: 131531 +// gas irOptimized code: 279600 // gas legacy: 151236 // gas legacy code: 533800 -// gas legacyOptimized: 131436 -// gas legacyOptimized code: 276600 -// gas ssaCFGOptimized: 132039 -// gas ssaCFGOptimized code: 282000 +// gas legacyOptimized: 130256 +// gas legacyOptimized code: 263600 +// gas ssaCFGOptimized: 130731 +// gas ssaCFGOptimized code: 268200 // exists() -> false // test_deploy_and_terminate() -> // ~ emit Deployed(address,bytes32) from 0x137aa4dfc0911524504fcd4d98501f179bc13b4a: 0x7e6580007e709ac52945fae182c61131d42634e8, 0x1234000000000000000000000000000000000000000000000000000000000000 -// gas irOptimized: 96528 +// gas irOptimized: 96481 // gas irOptimized code: 20800 // gas legacy: 97788 // gas legacy code: 20800 -// gas legacyOptimized: 96043 +// gas legacyOptimized: 95984 // gas legacyOptimized code: 20800 -// gas ssaCFGOptimized: 96391 +// gas ssaCFGOptimized: 96341 // gas ssaCFGOptimized code: 20800 // exists() -> false // deploy_create2() -> @@ -110,7 +110,7 @@ contract D { // test_balance_after_selfdestruct() -> // exists() -> true // deploy_create2() -> FAILURE -// gas irOptimized: 96903654 +// gas irOptimized: 96903653 // gas legacy: 96903658 // gas legacyOptimized: 96903639 // gas ssaCFGOptimized: 96903647 diff --git a/test/libsolidity/semanticTests/various/senders_balance.sol b/test/libsolidity/semanticTests/various/senders_balance.sol index 633cc18c6471..395a7bb0e158 100644 --- a/test/libsolidity/semanticTests/various/senders_balance.sol +++ b/test/libsolidity/semanticTests/various/senders_balance.sol @@ -16,12 +16,12 @@ contract D { } // ---- // constructor(), 27 wei -> -// gas irOptimized: 114057 -// gas irOptimized code: 53800 +// gas irOptimized: 113719 +// gas irOptimized code: 53200 // gas legacy: 117834 // gas legacy code: 100600 -// gas legacyOptimized: 113676 -// gas legacyOptimized code: 53600 -// gas ssaCFGOptimized: 113718 -// gas ssaCFGOptimized code: 49400 +// gas legacyOptimized: 113457 +// gas legacyOptimized code: 52400 +// gas ssaCFGOptimized: 113495 +// gas ssaCFGOptimized code: 48800 // f() -> 27 diff --git a/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol b/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol index ee9d75421940..05f71c42e3dd 100644 --- a/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol +++ b/test/libsolidity/semanticTests/various/skip_dynamic_types_for_structs.sol @@ -19,7 +19,7 @@ contract C { } // ---- // g() -> 2, 6 -// gas irOptimized: 178195 +// gas irOptimized: 178243 // gas legacy: 181357 -// gas legacyOptimized: 179055 -// gas ssaCFGOptimized: 178208 +// gas legacyOptimized: 179083 +// gas ssaCFGOptimized: 178256 diff --git a/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol b/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol index 74086d755281..0b5ee74d46e3 100644 --- a/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol +++ b/test/libsolidity/semanticTests/various/staticcall_for_view_and_pure.sol @@ -47,7 +47,7 @@ contract D { // gas ssaCFGOptimized: 98426763 // gas ssaCFGOptimized code: 11800 // fpure() -> FAILURE -// gas irOptimized: 98425388 +// gas irOptimized: 98425389 // gas irOptimized code: 13200 // gas legacy: 98413173 // gas legacy code: 25600 diff --git a/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol b/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol index 852de05a64f2..e75baa585604 100644 --- a/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol +++ b/test/libsolidity/semanticTests/viaYul/copy_struct_invalid_ir_bug.sol @@ -21,7 +21,7 @@ contract C { } // ---- // f() -> -// gas irOptimized: 113117 +// gas irOptimized: 113091 // gas legacy: 112888 -// gas legacyOptimized: 112580 -// gas ssaCFGOptimized: 113143 +// gas legacyOptimized: 112562 +// gas ssaCFGOptimized: 113092 diff --git a/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul b/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul index 4a29c1498d0e..c93843ff0629 100644 --- a/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul +++ b/test/libyul/objectCompiler/identical_subobjects_creation_deployed.yul @@ -69,38 +69,38 @@ object "A" { // outputs: Assembly // ---- // Assembly: -// sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // stop // // sub_0: assembly { -// sstore(calldataload(shl(0x7f, 0xffffffffffffffffffffffffffffffff)), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // stop // // sub_0: assembly { -// sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // stop // // sub_0: assembly { -// sstore(calldataload(shl(0x7f, 0xffffffffffffffffffffffffffffffff)), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // } // // sub_1: assembly { -// sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // } // } // } // // sub_1: assembly { -// sstore(calldataload(shl(0x7f, 0xffffffffffffffffffffffffffffffff)), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // } // // sub_2: assembly { -// sstore(calldataload(sub(shl(0xff, 0x01), shl(0x7f, 0x01))), calldataload(0x01)) +// sstore(calldataload(shl(0x7f, shr(0x80, not(0x00)))), calldataload(0x01)) // stop // } diff --git a/test/libyul/yulOptimizerTests/constantOptimiser/gaps.yul b/test/libyul/yulOptimizerTests/constantOptimiser/gaps.yul index 82dccdab41de..f7feda164b65 100644 --- a/test/libyul/yulOptimizerTests/constantOptimiser/gaps.yul +++ b/test/libyul/yulOptimizerTests/constantOptimiser/gaps.yul @@ -12,8 +12,8 @@ // // { // let a := shl(172, 1) -// let x := add(shl(248, 17), 0xffffffffffffffffffffffff23) -// let y := add(shl(220, 0x0fffffffff), 255) +// let x := 0x11000000000000000000000000000000000000ffffffffffffffffffffffff23 +// let y := not(shl(8, shr(44, not(0)))) // for { let i := 0xff00000000000 } // lt(i, 873687623427364) // { i := add(i, 3234234234234) } diff --git a/test/libyul/yulOptimizerTests/fullSuite/abi2.yul b/test/libyul/yulOptimizerTests/fullSuite/abi2.yul index 2f2e060be089..8c3a23b60b77 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/abi2.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/abi2.yul @@ -1080,7 +1080,7 @@ // let _1 := mload(1) // let _2 := mload(0) // if slt(sub(_1, _2), 64) { revert(0, 0) } -// sstore(0, and(calldataload(_2), sub(shl(160, 1), 1))) +// sstore(0, and(calldataload(_2), shr(96, not(0)))) // let x0, x1, x2, x3, x4 := abi_decode_addresst_uint256t_bytes_calldatat_enum_Operation(mload(7), mload(8)) // sstore(x1, x0) // sstore(x3, x2) @@ -1090,7 +1090,7 @@ // function abi_decode_addresst_uint256t_bytes_calldatat_enum_Operation(headStart, dataEnd) -> value0, value1, value2, value3, value4 // { // if slt(sub(dataEnd, headStart), 128) { revert(0, 0) } -// value0 := and(calldataload(headStart), sub(shl(160, 1), 1)) +// value0 := and(calldataload(headStart), shr(96, not(0))) // value1 := calldataload(add(headStart, 32)) // let offset := calldataload(add(headStart, 64)) // if gt(offset, 0xffffffffffffffff) { revert(0, 0) } @@ -1107,7 +1107,7 @@ // { // tail := add(headStart, 352) // mstore(headStart, value0) -// mstore(add(headStart, 32), and(value1, sub(shl(160, 1), 1))) +// mstore(add(headStart, 32), and(value1, shr(96, not(0)))) // mstore(add(headStart, 64), value2) // mstore(add(headStart, 96), value3) // if iszero(lt(value4, 3)) { invalid() } @@ -1115,8 +1115,8 @@ // mstore(add(headStart, 160), value5) // mstore(add(headStart, 192), value6) // mstore(add(headStart, 224), value7) -// mstore(add(headStart, 256), and(value8, sub(shl(160, 1), 1))) -// mstore(add(headStart, 288), and(value9, sub(shl(160, 1), 1))) +// mstore(add(headStart, 256), and(value8, shr(96, not(0)))) +// mstore(add(headStart, 288), and(value9, shr(96, not(0)))) // mstore(add(headStart, 320), value10) // } // function cleanup_revert_enum_Operation(value) -> cleaned diff --git a/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul b/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul index dbb87439f637..e1b524557641 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/abi_example1.yul @@ -478,7 +478,7 @@ // let i_1 := 0 // for { } lt(i_1, 0x3) { i_1 := add(i_1, 1) } // { -// mstore(pos_1, and(mload(srcPtr_1), sub(shl(160, 1), 1))) +// mstore(pos_1, and(mload(srcPtr_1), shr(96, not(0)))) // srcPtr_1 := add(srcPtr_1, 0x20) // pos_1 := add(pos_1, 0x20) // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_3.yul b/test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_3.yul index 17de07de7cd7..91344226dc36 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_3.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/combine_shift_and_and_3.yul @@ -24,9 +24,9 @@ // 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(17, and(_2, shl(4, shr(12, not(0))))) +// sstore(18, and(_2, shr(12, not(0)))) +// sstore(19, and(_1, shl(8, shr(12, not(0))))) // sstore(20, 0) // } // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul b/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul index 6ebca20f5bbb..4d2129dad0c2 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/create2_and_mask.yul @@ -13,7 +13,7 @@ // // { // { -// let a := and(create2(0, 0, 0x20, 0), sub(shl(160, 1), 1)) -// sstore(a, and(sub(shl(160, 1), 1), create2(0, 0, 0x20, 0))) +// let a := and(create2(0, 0, 0x20, 0), shr(96, not(0))) +// sstore(a, and(shr(96, not(0)), create2(0, 0, 0x20, 0))) // } // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul b/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul index 078616bb3b7e..f5e5abdc95ca 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/create_and_mask.yul @@ -13,7 +13,7 @@ // // { // { -// let a := and(create(0, 0, 0x20), sub(shl(160, 1), 1)) -// sstore(a, and(sub(shl(160, 1), 1), create(0, 0, 0x20))) +// let a := and(create(0, 0, 0x20), shr(96, not(0))) +// sstore(a, and(shr(96, not(0)), create(0, 0, 0x20))) // } // } diff --git a/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul b/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul index dd6cdc0e44c4..070a192b4321 100644 --- a/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul +++ b/test/libyul/yulOptimizerTests/fullSuite/extcodelength.yul @@ -24,7 +24,7 @@ // { // { // let value := calldataload(4) -// if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) } +// if iszero(eq(value, and(value, shr(96, not(0))))) { revert(0, 0) } // let length := extcodesize(value) // if gt(length, 0xffffffffffffffff) { revert(0, 0) } // let memPtr := mload(64)