diff options
31 files changed, 1348 insertions, 724 deletions
diff --git a/libevmasm/Assembly.h b/libevmasm/Assembly.h index 28328277..d48fa99c 100644 --- a/libevmasm/Assembly.h +++ b/libevmasm/Assembly.h @@ -26,7 +26,7 @@ #include <libdevcore/Common.h> #include <libdevcore/Assertions.h> #include <libdevcore/SHA3.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libevmasm/SourceLocation.h> #include <libevmasm/AssemblyItem.h> #include <libevmasm/LinkerObject.h> @@ -69,10 +69,10 @@ public: void appendProgramSize() { append(AssemblyItem(PushProgramSize)); } void appendLibraryAddress(std::string const& _identifier) { append(newPushLibraryAddress(_identifier)); } - AssemblyItem appendJump() { auto ret = append(newPushTag()); append(Instruction::JUMP); return ret; } - AssemblyItem appendJumpI() { auto ret = append(newPushTag()); append(Instruction::JUMPI); return ret; } - AssemblyItem appendJump(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(Instruction::JUMP); return ret; } - AssemblyItem appendJumpI(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(Instruction::JUMPI); return ret; } + AssemblyItem appendJump() { auto ret = append(newPushTag()); append(solidity::Instruction::JUMP); return ret; } + AssemblyItem appendJumpI() { auto ret = append(newPushTag()); append(solidity::Instruction::JUMPI); return ret; } + AssemblyItem appendJump(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(solidity::Instruction::JUMP); return ret; } + AssemblyItem appendJumpI(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(solidity::Instruction::JUMPI); return ret; } AssemblyItem errorTag() { return AssemblyItem(PushTag, 0); } template <class T> Assembly& operator<<(T const& _d) { append(_d); return *this; } @@ -86,7 +86,7 @@ public: void ignored() { m_baseDeposit = m_deposit; } void endIgnored() { m_deposit = m_baseDeposit; m_baseDeposit = 0; } - void popTo(int _deposit) { while (m_deposit > _deposit) append(Instruction::POP); } + void popTo(int _deposit) { while (m_deposit > _deposit) append(solidity::Instruction::POP); } void injectStart(AssemblyItem const& _i); std::string out() const; diff --git a/libevmasm/AssemblyItem.cpp b/libevmasm/AssemblyItem.cpp index d7051064..599ded85 100644 --- a/libevmasm/AssemblyItem.cpp +++ b/libevmasm/AssemblyItem.cpp @@ -94,7 +94,7 @@ ostream& dev::eth::operator<<(ostream& _out, AssemblyItem const& _item) { case Operation: _out << " " << instructionInfo(_item.instruction()).name; - if (_item.instruction() == eth::Instruction::JUMP || _item.instruction() == eth::Instruction::JUMPI) + if (_item.instruction() == solidity::Instruction::JUMP || _item.instruction() == solidity::Instruction::JUMPI) _out << "\t" << _item.getJumpTypeAsString(); break; case Push: diff --git a/libevmasm/AssemblyItem.h b/libevmasm/AssemblyItem.h index 795b5a8a..1c3d9789 100644 --- a/libevmasm/AssemblyItem.h +++ b/libevmasm/AssemblyItem.h @@ -25,9 +25,10 @@ #include <sstream> #include <libdevcore/Common.h> #include <libdevcore/Assertions.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libevmasm/SourceLocation.h> #include "Exceptions.h" +using namespace dev::solidity; namespace dev { @@ -57,7 +58,7 @@ public: AssemblyItem(u256 _push, SourceLocation const& _location = SourceLocation()): AssemblyItem(Push, _push, _location) { } - AssemblyItem(Instruction _i, SourceLocation const& _location = SourceLocation()): + AssemblyItem(solidity::Instruction _i, SourceLocation const& _location = SourceLocation()): AssemblyItem(Operation, byte(_i), _location) { } AssemblyItem(AssemblyItemType _type, u256 _data = 0, SourceLocation const& _location = SourceLocation()): m_type(_type), diff --git a/libevmasm/BlockDeduplicator.cpp b/libevmasm/BlockDeduplicator.cpp index d930ea22..3bb7a797 100644 --- a/libevmasm/BlockDeduplicator.cpp +++ b/libevmasm/BlockDeduplicator.cpp @@ -106,7 +106,7 @@ BlockDeduplicator::BlockIterator& BlockDeduplicator::BlockIterator::operator++() { if (it == end) return *this; - if (SemanticInformation::altersControlFlow(*it) && *it != AssemblyItem(eth::Instruction::JUMPI)) + if (SemanticInformation::altersControlFlow(*it) && *it != AssemblyItem(Instruction::JUMPI)) it = end; else { diff --git a/libevmasm/CMakeLists.txt b/libevmasm/CMakeLists.txt index 424644ca..c753fbe3 100644 --- a/libevmasm/CMakeLists.txt +++ b/libevmasm/CMakeLists.txt @@ -8,7 +8,7 @@ file(GLOB HEADERS "*.h") include_directories(BEFORE ..) add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS}) -eth_use(${EXECUTABLE} REQUIRED Eth::evmcore) +eth_use(${EXECUTABLE} REQUIRED Dev::devcore Eth::ethcore) install( TARGETS ${EXECUTABLE} RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib ) install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} ) diff --git a/libevmasm/GasMeter.cpp b/libevmasm/GasMeter.cpp index 93583169..40a67bb1 100644 --- a/libevmasm/GasMeter.cpp +++ b/libevmasm/GasMeter.cpp @@ -84,13 +84,13 @@ GasMeter::GasConsumption GasMeter::estimateMax(AssemblyItem const& _item) break; case Instruction::MLOAD: case Instruction::MSTORE: - gas += memoryGas(classes.find(eth::Instruction::ADD, { + gas += memoryGas(classes.find(Instruction::ADD, { m_state->relativeStackElement(0), classes.find(AssemblyItem(32)) })); break; case Instruction::MSTORE8: - gas += memoryGas(classes.find(eth::Instruction::ADD, { + gas += memoryGas(classes.find(Instruction::ADD, { m_state->relativeStackElement(0), classes.find(AssemblyItem(1)) })); @@ -198,7 +198,7 @@ GasMeter::GasConsumption GasMeter::memoryGas(int _stackPosOffset, int _stackPosS if (classes.knownZero(m_state->relativeStackElement(_stackPosSize))) return GasConsumption(0); else - return memoryGas(classes.find(eth::Instruction::ADD, { + return memoryGas(classes.find(Instruction::ADD, { m_state->relativeStackElement(_stackPosOffset), m_state->relativeStackElement(_stackPosSize) })); diff --git a/libevmasm/Instruction.cpp b/libevmasm/Instruction.cpp new file mode 100644 index 00000000..da765c41 --- /dev/null +++ b/libevmasm/Instruction.cpp @@ -0,0 +1,354 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>. +*/ +/** @file Instruction.cpp + * @author Gav Wood <i@gavwood.com> + * @date 2014 + */ + +#include "./Instruction.h" + +#include <functional> +#include <libdevcore/Common.h> +#include <libdevcore/CommonIO.h> +#include <libdevcore/Log.h> +using namespace std; +using namespace dev; +using namespace dev::solidity; + +const std::map<std::string, Instruction> dev::solidity::c_instructions = +{ + { "STOP", Instruction::STOP }, + { "ADD", Instruction::ADD }, + { "SUB", Instruction::SUB }, + { "MUL", Instruction::MUL }, + { "DIV", Instruction::DIV }, + { "SDIV", Instruction::SDIV }, + { "MOD", Instruction::MOD }, + { "SMOD", Instruction::SMOD }, + { "EXP", Instruction::EXP }, + { "BNOT", Instruction::NOT }, + { "LT", Instruction::LT }, + { "GT", Instruction::GT }, + { "SLT", Instruction::SLT }, + { "SGT", Instruction::SGT }, + { "EQ", Instruction::EQ }, + { "NOT", Instruction::ISZERO }, + { "AND", Instruction::AND }, + { "OR", Instruction::OR }, + { "XOR", Instruction::XOR }, + { "BYTE", Instruction::BYTE }, + { "ADDMOD", Instruction::ADDMOD }, + { "MULMOD", Instruction::MULMOD }, + { "SIGNEXTEND", Instruction::SIGNEXTEND }, + { "SHA3", Instruction::SHA3 }, + { "ADDRESS", Instruction::ADDRESS }, + { "BALANCE", Instruction::BALANCE }, + { "ORIGIN", Instruction::ORIGIN }, + { "CALLER", Instruction::CALLER }, + { "CALLVALUE", Instruction::CALLVALUE }, + { "CALLDATALOAD", Instruction::CALLDATALOAD }, + { "CALLDATASIZE", Instruction::CALLDATASIZE }, + { "CALLDATACOPY", Instruction::CALLDATACOPY }, + { "CODESIZE", Instruction::CODESIZE }, + { "CODECOPY", Instruction::CODECOPY }, + { "GASPRICE", Instruction::GASPRICE }, + { "EXTCODESIZE", Instruction::EXTCODESIZE }, + { "EXTCODECOPY", Instruction::EXTCODECOPY }, + { "BLOCKHASH", Instruction::BLOCKHASH }, + { "COINBASE", Instruction::COINBASE }, + { "TIMESTAMP", Instruction::TIMESTAMP }, + { "NUMBER", Instruction::NUMBER }, + { "DIFFICULTY", Instruction::DIFFICULTY }, + { "GASLIMIT", Instruction::GASLIMIT }, + { "POP", Instruction::POP }, + { "MLOAD", Instruction::MLOAD }, + { "MSTORE", Instruction::MSTORE }, + { "MSTORE8", Instruction::MSTORE8 }, + { "SLOAD", Instruction::SLOAD }, + { "SSTORE", Instruction::SSTORE }, + { "JUMP", Instruction::JUMP }, + { "JUMPI", Instruction::JUMPI }, + { "PC", Instruction::PC }, + { "MSIZE", Instruction::MSIZE }, + { "GAS", Instruction::GAS }, + { "JUMPDEST", Instruction::JUMPDEST }, + { "PUSH1", Instruction::PUSH1 }, + { "PUSH2", Instruction::PUSH2 }, + { "PUSH3", Instruction::PUSH3 }, + { "PUSH4", Instruction::PUSH4 }, + { "PUSH5", Instruction::PUSH5 }, + { "PUSH6", Instruction::PUSH6 }, + { "PUSH7", Instruction::PUSH7 }, + { "PUSH8", Instruction::PUSH8 }, + { "PUSH9", Instruction::PUSH9 }, + { "PUSH10", Instruction::PUSH10 }, + { "PUSH11", Instruction::PUSH11 }, + { "PUSH12", Instruction::PUSH12 }, + { "PUSH13", Instruction::PUSH13 }, + { "PUSH14", Instruction::PUSH14 }, + { "PUSH15", Instruction::PUSH15 }, + { "PUSH16", Instruction::PUSH16 }, + { "PUSH17", Instruction::PUSH17 }, + { "PUSH18", Instruction::PUSH18 }, + { "PUSH19", Instruction::PUSH19 }, + { "PUSH20", Instruction::PUSH20 }, + { "PUSH21", Instruction::PUSH21 }, + { "PUSH22", Instruction::PUSH22 }, + { "PUSH23", Instruction::PUSH23 }, + { "PUSH24", Instruction::PUSH24 }, + { "PUSH25", Instruction::PUSH25 }, + { "PUSH26", Instruction::PUSH26 }, + { "PUSH27", Instruction::PUSH27 }, + { "PUSH28", Instruction::PUSH28 }, + { "PUSH29", Instruction::PUSH29 }, + { "PUSH30", Instruction::PUSH30 }, + { "PUSH31", Instruction::PUSH31 }, + { "PUSH32", Instruction::PUSH32 }, + { "DUP1", Instruction::DUP1 }, + { "DUP2", Instruction::DUP2 }, + { "DUP3", Instruction::DUP3 }, + { "DUP4", Instruction::DUP4 }, + { "DUP5", Instruction::DUP5 }, + { "DUP6", Instruction::DUP6 }, + { "DUP7", Instruction::DUP7 }, + { "DUP8", Instruction::DUP8 }, + { "DUP9", Instruction::DUP9 }, + { "DUP10", Instruction::DUP10 }, + { "DUP11", Instruction::DUP11 }, + { "DUP12", Instruction::DUP12 }, + { "DUP13", Instruction::DUP13 }, + { "DUP14", Instruction::DUP14 }, + { "DUP15", Instruction::DUP15 }, + { "DUP16", Instruction::DUP16 }, + { "SWAP1", Instruction::SWAP1 }, + { "SWAP2", Instruction::SWAP2 }, + { "SWAP3", Instruction::SWAP3 }, + { "SWAP4", Instruction::SWAP4 }, + { "SWAP5", Instruction::SWAP5 }, + { "SWAP6", Instruction::SWAP6 }, + { "SWAP7", Instruction::SWAP7 }, + { "SWAP8", Instruction::SWAP8 }, + { "SWAP9", Instruction::SWAP9 }, + { "SWAP10", Instruction::SWAP10 }, + { "SWAP11", Instruction::SWAP11 }, + { "SWAP12", Instruction::SWAP12 }, + { "SWAP13", Instruction::SWAP13 }, + { "SWAP14", Instruction::SWAP14 }, + { "SWAP15", Instruction::SWAP15 }, + { "SWAP16", Instruction::SWAP16 }, + { "LOG0", Instruction::LOG0 }, + { "LOG1", Instruction::LOG1 }, + { "LOG2", Instruction::LOG2 }, + { "LOG3", Instruction::LOG3 }, + { "LOG4", Instruction::LOG4 }, + { "CREATE", Instruction::CREATE }, + { "CALL", Instruction::CALL }, + { "CALLCODE", Instruction::CALLCODE }, + { "RETURN", Instruction::RETURN }, + { "DELEGATECALL", Instruction::DELEGATECALL }, + { "SUICIDE", Instruction::SUICIDE } +}; + +static const std::map<Instruction, InstructionInfo> c_instructionInfo = +{ // Add, Args, Ret, SideEffects, GasPriceTier + { Instruction::STOP, { "STOP", 0, 0, 0, true, ZeroTier } }, + { Instruction::ADD, { "ADD", 0, 2, 1, false, VeryLowTier } }, + { Instruction::SUB, { "SUB", 0, 2, 1, false, VeryLowTier } }, + { Instruction::MUL, { "MUL", 0, 2, 1, false, LowTier } }, + { Instruction::DIV, { "DIV", 0, 2, 1, false, LowTier } }, + { Instruction::SDIV, { "SDIV", 0, 2, 1, false, LowTier } }, + { Instruction::MOD, { "MOD", 0, 2, 1, false, LowTier } }, + { Instruction::SMOD, { "SMOD", 0, 2, 1, false, LowTier } }, + { Instruction::EXP, { "EXP", 0, 2, 1, false, SpecialTier } }, + { Instruction::NOT, { "NOT", 0, 1, 1, false, VeryLowTier } }, + { Instruction::LT, { "LT", 0, 2, 1, false, VeryLowTier } }, + { Instruction::GT, { "GT", 0, 2, 1, false, VeryLowTier } }, + { Instruction::SLT, { "SLT", 0, 2, 1, false, VeryLowTier } }, + { Instruction::SGT, { "SGT", 0, 2, 1, false, VeryLowTier } }, + { Instruction::EQ, { "EQ", 0, 2, 1, false, VeryLowTier } }, + { Instruction::ISZERO, { "ISZERO", 0, 1, 1, false, VeryLowTier } }, + { Instruction::AND, { "AND", 0, 2, 1, false, VeryLowTier } }, + { Instruction::OR, { "OR", 0, 2, 1, false, VeryLowTier } }, + { Instruction::XOR, { "XOR", 0, 2, 1, false, VeryLowTier } }, + { Instruction::BYTE, { "BYTE", 0, 2, 1, false, VeryLowTier } }, + { Instruction::ADDMOD, { "ADDMOD", 0, 3, 1, false, MidTier } }, + { Instruction::MULMOD, { "MULMOD", 0, 3, 1, false, MidTier } }, + { Instruction::SIGNEXTEND, { "SIGNEXTEND", 0, 2, 1, false, LowTier } }, + { Instruction::SHA3, { "SHA3", 0, 2, 1, false, SpecialTier } }, + { Instruction::ADDRESS, { "ADDRESS", 0, 0, 1, false, BaseTier } }, + { Instruction::BALANCE, { "BALANCE", 0, 1, 1, false, ExtTier } }, + { Instruction::ORIGIN, { "ORIGIN", 0, 0, 1, false, BaseTier } }, + { Instruction::CALLER, { "CALLER", 0, 0, 1, false, BaseTier } }, + { Instruction::CALLVALUE, { "CALLVALUE", 0, 0, 1, false, BaseTier } }, + { Instruction::CALLDATALOAD,{ "CALLDATALOAD", 0, 1, 1, false, VeryLowTier } }, + { Instruction::CALLDATASIZE,{ "CALLDATASIZE", 0, 0, 1, false, BaseTier } }, + { Instruction::CALLDATACOPY,{ "CALLDATACOPY", 0, 3, 0, true, VeryLowTier } }, + { Instruction::CODESIZE, { "CODESIZE", 0, 0, 1, false, BaseTier } }, + { Instruction::CODECOPY, { "CODECOPY", 0, 3, 0, true, VeryLowTier } }, + { Instruction::GASPRICE, { "GASPRICE", 0, 0, 1, false, BaseTier } }, + { Instruction::EXTCODESIZE, { "EXTCODESIZE", 0, 1, 1, false, ExtTier } }, + { Instruction::EXTCODECOPY, { "EXTCODECOPY", 0, 4, 0, true, ExtTier } }, + { Instruction::BLOCKHASH, { "BLOCKHASH", 0, 1, 1, false, ExtTier } }, + { Instruction::COINBASE, { "COINBASE", 0, 0, 1, false, BaseTier } }, + { Instruction::TIMESTAMP, { "TIMESTAMP", 0, 0, 1, false, BaseTier } }, + { Instruction::NUMBER, { "NUMBER", 0, 0, 1, false, BaseTier } }, + { Instruction::DIFFICULTY, { "DIFFICULTY", 0, 0, 1, false, BaseTier } }, + { Instruction::GASLIMIT, { "GASLIMIT", 0, 0, 1, false, BaseTier } }, + { Instruction::POP, { "POP", 0, 1, 0, false, BaseTier } }, + { Instruction::MLOAD, { "MLOAD", 0, 1, 1, false, VeryLowTier } }, + { Instruction::MSTORE, { "MSTORE", 0, 2, 0, true, VeryLowTier } }, + { Instruction::MSTORE8, { "MSTORE8", 0, 2, 0, true, VeryLowTier } }, + { Instruction::SLOAD, { "SLOAD", 0, 1, 1, false, SpecialTier } }, + { Instruction::SSTORE, { "SSTORE", 0, 2, 0, true, SpecialTier } }, + { Instruction::JUMP, { "JUMP", 0, 1, 0, true, MidTier } }, + { Instruction::JUMPI, { "JUMPI", 0, 2, 0, true, HighTier } }, + { Instruction::PC, { "PC", 0, 0, 1, false, BaseTier } }, + { Instruction::MSIZE, { "MSIZE", 0, 0, 1, false, BaseTier } }, + { Instruction::GAS, { "GAS", 0, 0, 1, false, BaseTier } }, + { Instruction::JUMPDEST, { "JUMPDEST", 0, 0, 0, true, SpecialTier } }, + { Instruction::PUSH1, { "PUSH1", 1, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH2, { "PUSH2", 2, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH3, { "PUSH3", 3, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH4, { "PUSH4", 4, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH5, { "PUSH5", 5, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH6, { "PUSH6", 6, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH7, { "PUSH7", 7, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH8, { "PUSH8", 8, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH9, { "PUSH9", 9, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH10, { "PUSH10", 10, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH11, { "PUSH11", 11, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH12, { "PUSH12", 12, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH13, { "PUSH13", 13, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH14, { "PUSH14", 14, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH15, { "PUSH15", 15, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH16, { "PUSH16", 16, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH17, { "PUSH17", 17, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH18, { "PUSH18", 18, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH19, { "PUSH19", 19, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH20, { "PUSH20", 20, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH21, { "PUSH21", 21, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH22, { "PUSH22", 22, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH23, { "PUSH23", 23, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH24, { "PUSH24", 24, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH25, { "PUSH25", 25, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH26, { "PUSH26", 26, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH27, { "PUSH27", 27, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH28, { "PUSH28", 28, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH29, { "PUSH29", 29, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH30, { "PUSH30", 30, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH31, { "PUSH31", 31, 0, 1, false, VeryLowTier } }, + { Instruction::PUSH32, { "PUSH32", 32, 0, 1, false, VeryLowTier } }, + { Instruction::DUP1, { "DUP1", 0, 1, 2, false, VeryLowTier } }, + { Instruction::DUP2, { "DUP2", 0, 2, 3, false, VeryLowTier } }, + { Instruction::DUP3, { "DUP3", 0, 3, 4, false, VeryLowTier } }, + { Instruction::DUP4, { "DUP4", 0, 4, 5, false, VeryLowTier } }, + { Instruction::DUP5, { "DUP5", 0, 5, 6, false, VeryLowTier } }, + { Instruction::DUP6, { "DUP6", 0, 6, 7, false, VeryLowTier } }, + { Instruction::DUP7, { "DUP7", 0, 7, 8, false, VeryLowTier } }, + { Instruction::DUP8, { "DUP8", 0, 8, 9, false, VeryLowTier } }, + { Instruction::DUP9, { "DUP9", 0, 9, 10, false, VeryLowTier } }, + { Instruction::DUP10, { "DUP10", 0, 10, 11, false, VeryLowTier } }, + { Instruction::DUP11, { "DUP11", 0, 11, 12, false, VeryLowTier } }, + { Instruction::DUP12, { "DUP12", 0, 12, 13, false, VeryLowTier } }, + { Instruction::DUP13, { "DUP13", 0, 13, 14, false, VeryLowTier } }, + { Instruction::DUP14, { "DUP14", 0, 14, 15, false, VeryLowTier } }, + { Instruction::DUP15, { "DUP15", 0, 15, 16, false, VeryLowTier } }, + { Instruction::DUP16, { "DUP16", 0, 16, 17, false, VeryLowTier } }, + { Instruction::SWAP1, { "SWAP1", 0, 2, 2, false, VeryLowTier } }, + { Instruction::SWAP2, { "SWAP2", 0, 3, 3, false, VeryLowTier } }, + { Instruction::SWAP3, { "SWAP3", 0, 4, 4, false, VeryLowTier } }, + { Instruction::SWAP4, { "SWAP4", 0, 5, 5, false, VeryLowTier } }, + { Instruction::SWAP5, { "SWAP5", 0, 6, 6, false, VeryLowTier } }, + { Instruction::SWAP6, { "SWAP6", 0, 7, 7, false, VeryLowTier } }, + { Instruction::SWAP7, { "SWAP7", 0, 8, 8, false, VeryLowTier } }, + { Instruction::SWAP8, { "SWAP8", 0, 9, 9, false, VeryLowTier } }, + { Instruction::SWAP9, { "SWAP9", 0, 10, 10, false, VeryLowTier } }, + { Instruction::SWAP10, { "SWAP10", 0, 11, 11, false, VeryLowTier } }, + { Instruction::SWAP11, { "SWAP11", 0, 12, 12, false, VeryLowTier } }, + { Instruction::SWAP12, { "SWAP12", 0, 13, 13, false, VeryLowTier } }, + { Instruction::SWAP13, { "SWAP13", 0, 14, 14, false, VeryLowTier } }, + { Instruction::SWAP14, { "SWAP14", 0, 15, 15, false, VeryLowTier } }, + { Instruction::SWAP15, { "SWAP15", 0, 16, 16, false, VeryLowTier } }, + { Instruction::SWAP16, { "SWAP16", 0, 17, 17, false, VeryLowTier } }, + { Instruction::LOG0, { "LOG0", 0, 2, 0, true, SpecialTier } }, + { Instruction::LOG1, { "LOG1", 0, 3, 0, true, SpecialTier } }, + { Instruction::LOG2, { "LOG2", 0, 4, 0, true, SpecialTier } }, + { Instruction::LOG3, { "LOG3", 0, 5, 0, true, SpecialTier } }, + { Instruction::LOG4, { "LOG4", 0, 6, 0, true, SpecialTier } }, + { Instruction::CREATE, { "CREATE", 0, 3, 1, true, SpecialTier } }, + { Instruction::CALL, { "CALL", 0, 7, 1, true, SpecialTier } }, + { Instruction::CALLCODE, { "CALLCODE", 0, 7, 1, true, SpecialTier } }, + { Instruction::RETURN, { "RETURN", 0, 2, 0, true, ZeroTier } }, + { Instruction::DELEGATECALL,{ "DELEGATECALL", 0, 6, 1, true, SpecialTier } }, + { Instruction::SUICIDE, { "SUICIDE", 0, 1, 0, true, ZeroTier } } +}; + +void dev::solidity::eachInstruction( + bytes const& _mem, + function<void(Instruction,u256 const&)> const& _onInstruction +) +{ + for (auto it = _mem.begin(); it < _mem.end(); ++it) + { + Instruction instr = Instruction(*it); + size_t additional = 0; + if (isValidInstruction(instr)) + additional = instructionInfo(instr).additional; + u256 data; + for (size_t i = 0; i < additional; ++i) + { + data <<= 8; + if (++it < _mem.end()) + data |= *it; + } + _onInstruction(instr, data); + } +} + +string dev::solidity::disassemble(bytes const& _mem) +{ + stringstream ret; + eachInstruction(_mem, [&](Instruction _instr, u256 const& _data) { + if (!isValidInstruction(_instr)) + ret << "0x" << hex << int(_instr) << " "; + else + { + InstructionInfo info = instructionInfo(_instr); + ret << info.name << " "; + if (info.additional) + ret << "0x" << hex << _data << " "; + } + }); + return ret.str(); +} + +InstructionInfo dev::solidity::instructionInfo(Instruction _inst) +{ + try + { + return c_instructionInfo.at(_inst); + } + catch (...) + { + return InstructionInfo({"<INVALID_INSTRUCTION: " + toString((unsigned)_inst) + ">", 0, 0, 0, false, InvalidTier}); + } +} + +bool dev::solidity::isValidInstruction(Instruction _inst) +{ + return !!c_instructionInfo.count(_inst); +} diff --git a/libevmasm/Instruction.h b/libevmasm/Instruction.h new file mode 100644 index 00000000..0b06a677 --- /dev/null +++ b/libevmasm/Instruction.h @@ -0,0 +1,268 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>. +*/ +/** @file Instruction.h + * @author Gav Wood <i@gavwood.com> + * @date 2014 + */ + +#pragma once + +#include <functional> +#include <libdevcore/Common.h> +#include <libdevcore/Assertions.h> +#include "Exceptions.h" + +namespace dev +{ +namespace solidity +{ + +DEV_SIMPLE_EXCEPTION(InvalidDeposit); +DEV_SIMPLE_EXCEPTION(InvalidOpcode); + +/// Virtual machine bytecode instruction. +enum class Instruction: uint8_t +{ + STOP = 0x00, ///< halts execution + ADD, ///< addition operation + MUL, ///< mulitplication operation + SUB, ///< subtraction operation + DIV, ///< integer division operation + SDIV, ///< signed integer division operation + MOD, ///< modulo remainder operation + SMOD, ///< signed modulo remainder operation + ADDMOD, ///< unsigned modular addition + MULMOD, ///< unsigned modular multiplication + EXP, ///< exponential operation + SIGNEXTEND, ///< extend length of signed integer + + LT = 0x10, ///< less-than comparision + GT, ///< greater-than comparision + SLT, ///< signed less-than comparision + SGT, ///< signed greater-than comparision + EQ, ///< equality comparision + ISZERO, ///< simple not operator + AND, ///< bitwise AND operation + OR, ///< bitwise OR operation + XOR, ///< bitwise XOR operation + NOT, ///< bitwise NOT opertation + BYTE, ///< retrieve single byte from word + + SHA3 = 0x20, ///< compute SHA3-256 hash + + ADDRESS = 0x30, ///< get address of currently executing account + BALANCE, ///< get balance of the given account + ORIGIN, ///< get execution origination address + CALLER, ///< get caller address + CALLVALUE, ///< get deposited value by the instruction/transaction responsible for this execution + CALLDATALOAD, ///< get input data of current environment + CALLDATASIZE, ///< get size of input data in current environment + CALLDATACOPY, ///< copy input data in current environment to memory + CODESIZE, ///< get size of code running in current environment + CODECOPY, ///< copy code running in current environment to memory + GASPRICE, ///< get price of gas in current environment + EXTCODESIZE, ///< get external code size (from another contract) + EXTCODECOPY, ///< copy external code (from another contract) + + BLOCKHASH = 0x40, ///< get hash of most recent complete block + COINBASE, ///< get the block's coinbase address + TIMESTAMP, ///< get the block's timestamp + NUMBER, ///< get the block's number + DIFFICULTY, ///< get the block's difficulty + GASLIMIT, ///< get the block's gas limit + + POP = 0x50, ///< remove item from stack + MLOAD, ///< load word from memory + MSTORE, ///< save word to memory + MSTORE8, ///< save byte to memory + SLOAD, ///< load word from storage + SSTORE, ///< save word to storage + JUMP, ///< alter the program counter + JUMPI, ///< conditionally alter the program counter + PC, ///< get the program counter + MSIZE, ///< get the size of active memory + GAS, ///< get the amount of available gas + JUMPDEST, ///< set a potential jump destination + + PUSH1 = 0x60, ///< place 1 byte item on stack + PUSH2, ///< place 2 byte item on stack + PUSH3, ///< place 3 byte item on stack + PUSH4, ///< place 4 byte item on stack + PUSH5, ///< place 5 byte item on stack + PUSH6, ///< place 6 byte item on stack + PUSH7, ///< place 7 byte item on stack + PUSH8, ///< place 8 byte item on stack + PUSH9, ///< place 9 byte item on stack + PUSH10, ///< place 10 byte item on stack + PUSH11, ///< place 11 byte item on stack + PUSH12, ///< place 12 byte item on stack + PUSH13, ///< place 13 byte item on stack + PUSH14, ///< place 14 byte item on stack + PUSH15, ///< place 15 byte item on stack + PUSH16, ///< place 16 byte item on stack + PUSH17, ///< place 17 byte item on stack + PUSH18, ///< place 18 byte item on stack + PUSH19, ///< place 19 byte item on stack + PUSH20, ///< place 20 byte item on stack + PUSH21, ///< place 21 byte item on stack + PUSH22, ///< place 22 byte item on stack + PUSH23, ///< place 23 byte item on stack + PUSH24, ///< place 24 byte item on stack + PUSH25, ///< place 25 byte item on stack + PUSH26, ///< place 26 byte item on stack + PUSH27, ///< place 27 byte item on stack + PUSH28, ///< place 28 byte item on stack + PUSH29, ///< place 29 byte item on stack + PUSH30, ///< place 30 byte item on stack + PUSH31, ///< place 31 byte item on stack + PUSH32, ///< place 32 byte item on stack + + DUP1 = 0x80, ///< copies the highest item in the stack to the top of the stack + DUP2, ///< copies the second highest item in the stack to the top of the stack + DUP3, ///< copies the third highest item in the stack to the top of the stack + DUP4, ///< copies the 4th highest item in the stack to the top of the stack + DUP5, ///< copies the 5th highest item in the stack to the top of the stack + DUP6, ///< copies the 6th highest item in the stack to the top of the stack + DUP7, ///< copies the 7th highest item in the stack to the top of the stack + DUP8, ///< copies the 8th highest item in the stack to the top of the stack + DUP9, ///< copies the 9th highest item in the stack to the top of the stack + DUP10, ///< copies the 10th highest item in the stack to the top of the stack + DUP11, ///< copies the 11th highest item in the stack to the top of the stack + DUP12, ///< copies the 12th highest item in the stack to the top of the stack + DUP13, ///< copies the 13th highest item in the stack to the top of the stack + DUP14, ///< copies the 14th highest item in the stack to the top of the stack + DUP15, ///< copies the 15th highest item in the stack to the top of the stack + DUP16, ///< copies the 16th highest item in the stack to the top of the stack + + SWAP1 = 0x90, ///< swaps the highest and second highest value on the stack + SWAP2, ///< swaps the highest and third highest value on the stack + SWAP3, ///< swaps the highest and 4th highest value on the stack + SWAP4, ///< swaps the highest and 5th highest value on the stack + SWAP5, ///< swaps the highest and 6th highest value on the stack + SWAP6, ///< swaps the highest and 7th highest value on the stack + SWAP7, ///< swaps the highest and 8th highest value on the stack + SWAP8, ///< swaps the highest and 9th highest value on the stack + SWAP9, ///< swaps the highest and 10th highest value on the stack + SWAP10, ///< swaps the highest and 11th highest value on the stack + SWAP11, ///< swaps the highest and 12th highest value on the stack + SWAP12, ///< swaps the highest and 13th highest value on the stack + SWAP13, ///< swaps the highest and 14th highest value on the stack + SWAP14, ///< swaps the highest and 15th highest value on the stack + SWAP15, ///< swaps the highest and 16th highest value on the stack + SWAP16, ///< swaps the highest and 17th highest value on the stack + + LOG0 = 0xa0, ///< Makes a log entry; no topics. + LOG1, ///< Makes a log entry; 1 topic. + LOG2, ///< Makes a log entry; 2 topics. + LOG3, ///< Makes a log entry; 3 topics. + LOG4, ///< Makes a log entry; 4 topics. + + CREATE = 0xf0, ///< create a new account with associated code + CALL, ///< message-call into an account + CALLCODE, ///< message-call with another account's code only + RETURN, ///< halt execution returning output data + DELEGATECALL, ///< like CALLCODE but keeps caller's value and sender + SUICIDE = 0xff ///< halt execution and register account for later deletion +}; + +/// @returns the number of PUSH Instruction _inst +inline unsigned getPushNumber(Instruction _inst) +{ + return (byte)_inst - unsigned(Instruction::PUSH1) + 1; +} + +/// @returns the number of DUP Instruction _inst +inline unsigned getDupNumber(Instruction _inst) +{ + return (byte)_inst - unsigned(Instruction::DUP1) + 1; +} + +/// @returns the number of SWAP Instruction _inst +inline unsigned getSwapNumber(Instruction _inst) +{ + return (byte)_inst - unsigned(Instruction::SWAP1) + 1; +} + +/// @returns the PUSH<_number> instruction +inline Instruction pushInstruction(unsigned _number) +{ + assertThrow(1 <= _number && _number <= 32, InvalidOpcode, "Invalid PUSH instruction requested."); + return Instruction(unsigned(Instruction::PUSH1) + _number - 1); +} + +/// @returns the DUP<_number> instruction +inline Instruction dupInstruction(unsigned _number) +{ + assertThrow(1 <= _number && _number <= 16, InvalidOpcode, "Invalid DUP instruction requested."); + return Instruction(unsigned(Instruction::DUP1) + _number - 1); +} + +/// @returns the SWAP<_number> instruction +inline Instruction swapInstruction(unsigned _number) +{ + assertThrow(1 <= _number && _number <= 16, InvalidOpcode, "Invalid SWAP instruction requested."); + return Instruction(unsigned(Instruction::SWAP1) + _number - 1); +} + +/// @returns the LOG<_number> instruction +inline Instruction logInstruction(unsigned _number) +{ + assertThrow(_number <= 4, InvalidOpcode, "Invalid LOG instruction requested."); + return Instruction(unsigned(Instruction::LOG0) + _number); +} + +enum Tier +{ + ZeroTier = 0, // 0, Zero + BaseTier, // 2, Quick + VeryLowTier, // 3, Fastest + LowTier, // 5, Fast + MidTier, // 8, Mid + HighTier, // 10, Slow + ExtTier, // 20, Ext + SpecialTier, // multiparam or otherwise special + InvalidTier // Invalid. +}; + +/// Information structure for a particular instruction. +struct InstructionInfo +{ + std::string name; ///< The name of the instruction. + int additional; ///< Additional items required in memory for this instructions (only for PUSH). + int args; ///< Number of items required on the stack for this instruction (and, for the purposes of ret, the number taken from the stack). + int ret; ///< Number of items placed (back) on the stack by this instruction, assuming args items were removed. + bool sideEffects; ///< false if the only effect on the execution environment (apart from gas usage) is a change to a topmost segment of the stack + int gasPriceTier; ///< Tier for gas pricing. +}; + +/// Information on all the instructions. +InstructionInfo instructionInfo(Instruction _inst); + +/// check whether instructions exists +bool isValidInstruction(Instruction _inst); + +/// Convert from string mnemonic to Instruction type. +extern const std::map<std::string, Instruction> c_instructions; + +/// Iterate through EVM code and call a function on each instruction. +void eachInstruction(bytes const& _mem, std::function<void(Instruction,u256 const&)> const& _onInstruction); + +/// Convert from EVM code to simple EVM assembly language. +std::string disassemble(bytes const& _mem); + +} +} diff --git a/libevmasm/PathGasMeter.cpp b/libevmasm/PathGasMeter.cpp index 8f7314f8..2113008b 100644 --- a/libevmasm/PathGasMeter.cpp +++ b/libevmasm/PathGasMeter.cpp @@ -76,7 +76,7 @@ GasMeter::GasConsumption PathGasMeter::handleQueueItem() bool branchStops = false; jumpTags.clear(); AssemblyItem const& item = m_items.at(index); - if (item.type() == Tag || item == AssemblyItem(eth::Instruction::JUMPDEST)) + if (item.type() == Tag || item == AssemblyItem(Instruction::JUMPDEST)) { // Do not allow any backwards jump. This is quite restrictive but should work for // the simplest things. @@ -84,14 +84,14 @@ GasMeter::GasConsumption PathGasMeter::handleQueueItem() return GasMeter::GasConsumption::infinite(); path->visitedJumpdests.insert(index); } - else if (item == AssemblyItem(eth::Instruction::JUMP)) + else if (item == AssemblyItem(Instruction::JUMP)) { branchStops = true; jumpTags = state->tagsInExpression(state->relativeStackElement(0)); if (jumpTags.empty()) // unknown jump destination return GasMeter::GasConsumption::infinite(); } - else if (item == AssemblyItem(eth::Instruction::JUMPI)) + else if (item == AssemblyItem(Instruction::JUMPI)) { ExpressionClasses::Id condition = state->relativeStackElement(-1); if (classes.knownNonZero(condition) || !classes.knownZero(condition)) diff --git a/libevmasm/SemanticInformation.h b/libevmasm/SemanticInformation.h index 094f4591..0eda5ed5 100644 --- a/libevmasm/SemanticInformation.h +++ b/libevmasm/SemanticInformation.h @@ -23,7 +23,7 @@ #pragma once -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> namespace dev { @@ -50,9 +50,9 @@ struct SemanticInformation /// the information in the current block header, memory, storage or stack. static bool isDeterministic(AssemblyItem const& _item); /// @returns true if the given instruction modifies memory. - static bool invalidatesMemory(Instruction _instruction); + static bool invalidatesMemory(solidity::Instruction _instruction); /// @returns true if the given instruction modifies storage (even indirectly). - static bool invalidatesStorage(Instruction _instruction); + static bool invalidatesStorage(solidity::Instruction _instruction); }; } diff --git a/liblll/CodeFragment.cpp b/liblll/CodeFragment.cpp index 64680d5a..7998a5b5 100644 --- a/liblll/CodeFragment.cpp +++ b/liblll/CodeFragment.cpp @@ -30,7 +30,7 @@ #pragma GCC diagnostic pop #include <libdevcore/Log.h> #include <libdevcore/CommonIO.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include "CompilerState.h" #include "Parser.h" using namespace std; diff --git a/liblll/CodeFragment.h b/liblll/CodeFragment.h index 03f812b6..e0d48ab7 100644 --- a/liblll/CodeFragment.h +++ b/liblll/CodeFragment.h @@ -22,7 +22,7 @@ #pragma once #include <libdevcore/Common.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libevmasm/Assembly.h> #include "Exceptions.h" diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp index c63b6b5a..bc342b58 100644 --- a/libsolidity/analysis/TypeChecker.cpp +++ b/libsolidity/analysis/TypeChecker.cpp @@ -595,7 +595,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly) if (!varDecl->isLocalVariable()) return false; // only local variables are inline-assemlby lvalues for (unsigned i = 0; i < declaration->type()->sizeOnStack(); ++i) - _assembly.append(eth::Instruction::POP); // remove value just to verify the stack height + _assembly.append(Instruction::POP); // remove value just to verify the stack height } else return false; diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h index 7bb2529a..bf275869 100644 --- a/libsolidity/ast/AST.h +++ b/libsolidity/ast/AST.h @@ -28,7 +28,7 @@ #include <memory> #include <boost/noncopyable.hpp> #include <libevmasm/SourceLocation.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libsolidity/interface/Utils.h> #include <libsolidity/ast/ASTForward.h> #include <libsolidity/parsing/Token.h> diff --git a/libsolidity/codegen/ArrayUtils.cpp b/libsolidity/codegen/ArrayUtils.cpp index f1acce31..8e568be5 100644 --- a/libsolidity/codegen/ArrayUtils.cpp +++ b/libsolidity/codegen/ArrayUtils.cpp @@ -21,7 +21,7 @@ */ #include <libsolidity/codegen/ArrayUtils.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libsolidity/codegen/CompilerContext.h> #include <libsolidity/codegen/CompilerUtils.h> #include <libsolidity/ast/Types.h> @@ -56,7 +56,7 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons // stack: source_ref [source_length] target_ref // store target_ref for (unsigned i = _sourceType.sizeOnStack(); i > 0; --i) - m_context << eth::swapInstruction(i); + m_context << swapInstruction(i); // stack: target_ref source_ref [source_length] // stack: target_ref source_ref [source_length] // retrieve source length @@ -65,12 +65,12 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons if (_sourceType.location() == DataLocation::Memory && _sourceType.isDynamicallySized()) { // increment source pointer to point to data - m_context << eth::Instruction::SWAP1 << u256(0x20); - m_context << eth::Instruction::ADD << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1 << u256(0x20); + m_context << Instruction::ADD << Instruction::SWAP1; } // stack: target_ref source_ref source_length - m_context << eth::Instruction::DUP3; + m_context << Instruction::DUP3; // stack: target_ref source_ref source_length target_ref retrieveLength(_targetType); // stack: target_ref source_ref source_length target_ref target_length @@ -78,28 +78,28 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons // store new target length if (!_targetType.isByteArray()) // Otherwise, length will be stored below. - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP3 << eth::Instruction::SSTORE; + m_context << Instruction::DUP3 << Instruction::DUP3 << Instruction::SSTORE; if (sourceBaseType->category() == Type::Category::Mapping) { solAssert(targetBaseType->category() == Type::Category::Mapping, ""); solAssert(_sourceType.location() == DataLocation::Storage, ""); // nothing to copy m_context - << eth::Instruction::POP << eth::Instruction::POP - << eth::Instruction::POP << eth::Instruction::POP; + << Instruction::POP << Instruction::POP + << Instruction::POP << Instruction::POP; return; } // stack: target_ref source_ref source_length target_ref target_length // compute hashes (data positions) - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; if (_targetType.isDynamicallySized()) CompilerUtils(m_context).computeHashStatic(); // stack: target_ref source_ref source_length target_length target_data_pos - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; convertLengthToSize(_targetType); - m_context << eth::Instruction::DUP2 << eth::Instruction::ADD; + m_context << Instruction::DUP2 << Instruction::ADD; // stack: target_ref source_ref source_length target_data_pos target_data_end - m_context << eth::Instruction::SWAP3; + m_context << Instruction::SWAP3; // stack: target_ref target_data_end source_length target_data_pos source_ref eth::AssemblyItem copyLoopEndWithoutByteOffset = m_context.newTag(); @@ -108,47 +108,47 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons if (_targetType.isByteArray()) { // stack: target_ref target_data_end source_length target_data_pos source_ref - m_context << eth::Instruction::DUP3 << u256(31) << eth::Instruction::LT; + m_context << Instruction::DUP3 << u256(31) << Instruction::LT; eth::AssemblyItem longByteArray = m_context.appendConditionalJump(); // store the short byte array solAssert(_sourceType.isByteArray(), ""); if (_sourceType.location() == DataLocation::Storage) { // just copy the slot, it contains length and data - m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD; - m_context << eth::Instruction::DUP6 << eth::Instruction::SSTORE; + m_context << Instruction::DUP1 << Instruction::SLOAD; + m_context << Instruction::DUP6 << Instruction::SSTORE; } else { - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; CompilerUtils(m_context).loadFromMemoryDynamic(*sourceBaseType, fromCalldata, true, false); // stack: target_ref target_data_end source_length target_data_pos source_ref value // clear the lower-order byte - which will hold the length - m_context << u256(0xff) << eth::Instruction::NOT << eth::Instruction::AND; + m_context << u256(0xff) << Instruction::NOT << Instruction::AND; // fetch the length and shift it left by one - m_context << eth::Instruction::DUP4 << eth::Instruction::DUP1 << eth::Instruction::ADD; + m_context << Instruction::DUP4 << Instruction::DUP1 << Instruction::ADD; // combine value and length and store them - m_context << eth::Instruction::OR << eth::Instruction::DUP6 << eth::Instruction::SSTORE; + m_context << Instruction::OR << Instruction::DUP6 << Instruction::SSTORE; } // end of special case, jump right into cleaning target data area m_context.appendJumpTo(copyLoopEndWithoutByteOffset); m_context << longByteArray; // Store length (2*length+1) - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP1 << eth::Instruction::ADD; - m_context << u256(1) << eth::Instruction::ADD; - m_context << eth::Instruction::DUP6 << eth::Instruction::SSTORE; + m_context << Instruction::DUP3 << Instruction::DUP1 << Instruction::ADD; + m_context << u256(1) << Instruction::ADD; + m_context << Instruction::DUP6 << Instruction::SSTORE; } // skip copying if source length is zero - m_context << eth::Instruction::DUP3 << eth::Instruction::ISZERO; + m_context << Instruction::DUP3 << Instruction::ISZERO; m_context.appendConditionalJumpTo(copyLoopEndWithoutByteOffset); if (_sourceType.location() == DataLocation::Storage && _sourceType.isDynamicallySized()) CompilerUtils(m_context).computeHashStatic(); // stack: target_ref target_data_end source_length target_data_pos source_data_pos - m_context << eth::Instruction::SWAP2; + m_context << Instruction::SWAP2; convertLengthToSize(_sourceType); - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << Instruction::DUP3 << Instruction::ADD; // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end if (haveByteOffsetTarget) m_context << u256(0); @@ -159,8 +159,8 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons m_context << copyLoopStart; // check for loop condition m_context - << eth::dupInstruction(3 + byteOffsetSize) << eth::dupInstruction(2 + byteOffsetSize) - << eth::Instruction::GT << eth::Instruction::ISZERO; + << dupInstruction(3 + byteOffsetSize) << dupInstruction(2 + byteOffsetSize) + << Instruction::GT << Instruction::ISZERO; eth::AssemblyItem copyLoopEnd = m_context.appendConditionalJump(); // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] // copy @@ -168,19 +168,19 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons { solAssert(byteOffsetSize == 0, "Byte offset for array as base type."); auto const& sourceBaseArrayType = dynamic_cast<ArrayType const&>(*sourceBaseType); - m_context << eth::Instruction::DUP3; + m_context << Instruction::DUP3; if (sourceBaseArrayType.location() == DataLocation::Memory) - m_context << eth::Instruction::MLOAD; - m_context << eth::Instruction::DUP3; + m_context << Instruction::MLOAD; + m_context << Instruction::DUP3; copyArrayToStorage(dynamic_cast<ArrayType const&>(*targetBaseType), sourceBaseArrayType); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else if (directCopy) { solAssert(byteOffsetSize == 0, "Byte offset for direct copy."); m_context - << eth::Instruction::DUP3 << eth::Instruction::SLOAD - << eth::Instruction::DUP3 << eth::Instruction::SSTORE; + << Instruction::DUP3 << Instruction::SLOAD + << Instruction::DUP3 << Instruction::SSTORE; } else { @@ -188,11 +188,11 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons // We might copy too much if there is padding at the last element, but this way end // checking is easier. // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] - m_context << eth::dupInstruction(3 + byteOffsetSize); + m_context << dupInstruction(3 + byteOffsetSize); if (_sourceType.location() == DataLocation::Storage) { if (haveByteOffsetSource) - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP2; else m_context << u256(0); StorageItem(m_context, *sourceBaseType).retrieveValue(SourceLocation(), true); @@ -207,9 +207,9 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons "Stack too deep, try removing local variables." ); // fetch target storage reference - m_context << eth::dupInstruction(2 + byteOffsetSize + sourceBaseType->sizeOnStack()); + m_context << dupInstruction(2 + byteOffsetSize + sourceBaseType->sizeOnStack()); if (haveByteOffsetTarget) - m_context << eth::dupInstruction(1 + byteOffsetSize + sourceBaseType->sizeOnStack()); + m_context << dupInstruction(1 + byteOffsetSize + sourceBaseType->sizeOnStack()); else m_context << u256(0); StorageItem(m_context, *targetBaseType).storeValue(*sourceBaseType, SourceLocation(), true); @@ -220,7 +220,7 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons incrementByteOffset(sourceBaseType->storageBytes(), 1, haveByteOffsetTarget ? 5 : 4); else { - m_context << eth::swapInstruction(2 + byteOffsetSize); + m_context << swapInstruction(2 + byteOffsetSize); if (sourceIsStorage) m_context << sourceBaseType->storageSize(); else if (_sourceType.location() == DataLocation::Memory) @@ -228,44 +228,44 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons else m_context << sourceBaseType->calldataEncodedSize(true); m_context - << eth::Instruction::ADD - << eth::swapInstruction(2 + byteOffsetSize); + << Instruction::ADD + << swapInstruction(2 + byteOffsetSize); } // increment target if (haveByteOffsetTarget) incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2); else m_context - << eth::swapInstruction(1 + byteOffsetSize) + << swapInstruction(1 + byteOffsetSize) << targetBaseType->storageSize() - << eth::Instruction::ADD - << eth::swapInstruction(1 + byteOffsetSize); + << Instruction::ADD + << swapInstruction(1 + byteOffsetSize); m_context.appendJumpTo(copyLoopStart); m_context << copyLoopEnd; if (haveByteOffsetTarget) { // clear elements that might be left over in the current slot in target // stack: target_ref target_data_end source_data_pos target_data_pos source_data_end target_byte_offset [source_byte_offset] - m_context << eth::dupInstruction(byteOffsetSize) << eth::Instruction::ISZERO; + m_context << dupInstruction(byteOffsetSize) << Instruction::ISZERO; eth::AssemblyItem copyCleanupLoopEnd = m_context.appendConditionalJump(); - m_context << eth::dupInstruction(2 + byteOffsetSize) << eth::dupInstruction(1 + byteOffsetSize); + m_context << dupInstruction(2 + byteOffsetSize) << dupInstruction(1 + byteOffsetSize); StorageItem(m_context, *targetBaseType).setToZero(SourceLocation(), true); incrementByteOffset(targetBaseType->storageBytes(), byteOffsetSize, byteOffsetSize + 2); m_context.appendJumpTo(copyLoopEnd); m_context << copyCleanupLoopEnd; - m_context << eth::Instruction::POP; // might pop the source, but then target is popped next + m_context << Instruction::POP; // might pop the source, but then target is popped next } if (haveByteOffsetSource) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; m_context << copyLoopEndWithoutByteOffset; // zero-out leftovers in target // stack: target_ref target_data_end source_data_pos target_data_pos_updated source_data_end - m_context << eth::Instruction::POP << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::POP << Instruction::SWAP1 << Instruction::POP; // stack: target_ref target_data_end target_data_pos_updated clearStorageLoop(*targetBaseType); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWordBoundaries) const @@ -285,13 +285,13 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord if (!_sourceType.isDynamicallySized()) m_context << _sourceType.length(); if (baseSize > 1) - m_context << u256(baseSize) << eth::Instruction::MUL; + m_context << u256(baseSize) << Instruction::MUL; // stack: target source_offset source_len - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3 << eth::Instruction::DUP5; + m_context << Instruction::DUP1 << Instruction::DUP3 << Instruction::DUP5; // stack: target source_offset source_len source_len source_offset target - m_context << eth::Instruction::CALLDATACOPY; - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP2 << eth::Instruction::POP << eth::Instruction::POP; + m_context << Instruction::CALLDATACOPY; + m_context << Instruction::DUP3 << Instruction::ADD; + m_context << Instruction::SWAP2 << Instruction::POP << Instruction::POP; } else if (_sourceType.location() == DataLocation::Memory) { @@ -300,25 +300,25 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord if (!_sourceType.baseType()->isValueType()) { // copy using a loop - m_context << u256(0) << eth::Instruction::SWAP3; + m_context << u256(0) << Instruction::SWAP3; // stack: counter source length target auto repeat = m_context.newTag(); m_context << repeat; - m_context << eth::Instruction::DUP2 << eth::Instruction::DUP5; - m_context << eth::Instruction::LT << eth::Instruction::ISZERO; + m_context << Instruction::DUP2 << Instruction::DUP5; + m_context << Instruction::LT << Instruction::ISZERO; auto loopEnd = m_context.appendConditionalJump(); - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP5; + m_context << Instruction::DUP3 << Instruction::DUP5; accessIndex(_sourceType, false); MemoryItem(m_context, *_sourceType.baseType(), true).retrieveValue(SourceLocation(), true); if (auto baseArray = dynamic_cast<ArrayType const*>(_sourceType.baseType().get())) copyArrayToMemory(*baseArray, _padToWordBoundaries); else utils.storeInMemoryDynamic(*_sourceType.baseType()); - m_context << eth::Instruction::SWAP3 << u256(1) << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP3; + m_context << Instruction::SWAP3 << u256(1) << Instruction::ADD; + m_context << Instruction::SWAP3; m_context.appendJumpTo(repeat); m_context << loopEnd; - m_context << eth::Instruction::SWAP3; + m_context << Instruction::SWAP3; utils.popStackSlots(3); // stack: updated_target_pos return; @@ -328,18 +328,18 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord if (_sourceType.isDynamicallySized()) { // change pointer to data part - m_context << eth::Instruction::SWAP1 << u256(32) << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1 << u256(32) << Instruction::ADD; + m_context << Instruction::SWAP1; } // convert length to size if (baseSize > 1) - m_context << u256(baseSize) << eth::Instruction::MUL; + m_context << u256(baseSize) << Instruction::MUL; // stack: <target> <source> <size> //@TODO do not use ::CALL if less than 32 bytes? - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP4 << eth::Instruction::DUP4; + m_context << Instruction::DUP1 << Instruction::DUP4 << Instruction::DUP4; utils.memoryCopy(); - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; // stack: <target> <size> bool paddingNeeded = false; @@ -350,43 +350,43 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord if (paddingNeeded) { // stack: <target> <size> - m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2 << eth::Instruction::ADD; + m_context << Instruction::SWAP1 << Instruction::DUP2 << Instruction::ADD; // stack: <length> <target + size> - m_context << eth::Instruction::SWAP1 << u256(31) << eth::Instruction::AND; + m_context << Instruction::SWAP1 << u256(31) << Instruction::AND; // stack: <target + size> <remainder = size % 32> eth::AssemblyItem skip = m_context.newTag(); if (_sourceType.isDynamicallySized()) { - m_context << eth::Instruction::DUP1 << eth::Instruction::ISZERO; + m_context << Instruction::DUP1 << Instruction::ISZERO; m_context.appendConditionalJumpTo(skip); } // round off, load from there. // stack <target + size> <remainder = size % 32> - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3; - m_context << eth::Instruction::SUB; + m_context << Instruction::DUP1 << Instruction::DUP3; + m_context << Instruction::SUB; // stack: target+size remainder <target + size - remainder> - m_context << eth::Instruction::DUP1 << eth::Instruction::MLOAD; + m_context << Instruction::DUP1 << Instruction::MLOAD; // Now we AND it with ~(2**(8 * (32 - remainder)) - 1) m_context << u256(1); - m_context << eth::Instruction::DUP4 << u256(32) << eth::Instruction::SUB; + m_context << Instruction::DUP4 << u256(32) << Instruction::SUB; // stack: ...<v> 1 <32 - remainder> - m_context << u256(0x100) << eth::Instruction::EXP << eth::Instruction::SUB; - m_context << eth::Instruction::NOT << eth::Instruction::AND; + m_context << u256(0x100) << Instruction::EXP << Instruction::SUB; + m_context << Instruction::NOT << Instruction::AND; // stack: target+size remainder target+size-remainder <v & ...> - m_context << eth::Instruction::DUP2 << eth::Instruction::MSTORE; + m_context << Instruction::DUP2 << Instruction::MSTORE; // stack: target+size remainder target+size-remainder - m_context << u256(32) << eth::Instruction::ADD; + m_context << u256(32) << Instruction::ADD; // stack: target+size remainder <new_padded_end> - m_context << eth::Instruction::SWAP2 << eth::Instruction::POP; + m_context << Instruction::SWAP2 << Instruction::POP; if (_sourceType.isDynamicallySized()) m_context << skip.tag(); // stack <target + "size"> <remainder = size % 32> - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else // stack: <target> <size> - m_context << eth::Instruction::ADD; + m_context << Instruction::ADD; } else { @@ -398,48 +398,48 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord retrieveLength(_sourceType); // stack here: memory_offset storage_offset length // jump to end if length is zero - m_context << eth::Instruction::DUP1 << eth::Instruction::ISZERO; + m_context << Instruction::DUP1 << Instruction::ISZERO; eth::AssemblyItem loopEnd = m_context.appendConditionalJump(); // Special case for tightly-stored byte arrays if (_sourceType.isByteArray()) { // stack here: memory_offset storage_offset length - m_context << eth::Instruction::DUP1 << u256(31) << eth::Instruction::LT; + m_context << Instruction::DUP1 << u256(31) << Instruction::LT; eth::AssemblyItem longByteArray = m_context.appendConditionalJump(); // store the short byte array (discard lower-order byte) - m_context << u256(0x100) << eth::Instruction::DUP1; - m_context << eth::Instruction::DUP4 << eth::Instruction::SLOAD; - m_context << eth::Instruction::DIV << eth::Instruction::MUL; - m_context << eth::Instruction::DUP4 << eth::Instruction::MSTORE; + m_context << u256(0x100) << Instruction::DUP1; + m_context << Instruction::DUP4 << Instruction::SLOAD; + m_context << Instruction::DIV << Instruction::MUL; + m_context << Instruction::DUP4 << Instruction::MSTORE; // stack here: memory_offset storage_offset length // add 32 or length to memory offset - m_context << eth::Instruction::SWAP2; + m_context << Instruction::SWAP2; if (_padToWordBoundaries) m_context << u256(32); else - m_context << eth::Instruction::DUP3; - m_context << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP2; + m_context << Instruction::DUP3; + m_context << Instruction::ADD; + m_context << Instruction::SWAP2; m_context.appendJumpTo(loopEnd); m_context << longByteArray; } // compute memory end offset if (baseSize > 1) // convert length to memory size - m_context << u256(baseSize) << eth::Instruction::MUL; - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD << eth::Instruction::SWAP2; + m_context << u256(baseSize) << Instruction::MUL; + m_context << Instruction::DUP3 << Instruction::ADD << Instruction::SWAP2; if (_sourceType.isDynamicallySized()) { // actual array data is stored at SHA3(storage_offset) - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; utils.computeHashStatic(); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; } // stack here: memory_end_offset storage_data_offset memory_offset bool haveByteOffset = !_sourceType.isByteArray() && storageBytes <= 16; if (haveByteOffset) - m_context << u256(0) << eth::Instruction::SWAP1; + m_context << u256(0) << Instruction::SWAP1; // stack here: memory_end_offset storage_data_offset [storage_byte_offset] memory_offset eth::AssemblyItem loopStart = m_context.newTag(); m_context << loopStart; @@ -447,20 +447,20 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord if (_sourceType.isByteArray()) { // Packed both in storage and memory. - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD; - m_context << eth::Instruction::DUP2 << eth::Instruction::MSTORE; + m_context << Instruction::DUP2 << Instruction::SLOAD; + m_context << Instruction::DUP2 << Instruction::MSTORE; // increment storage_data_offset by 1 - m_context << eth::Instruction::SWAP1 << u256(1) << eth::Instruction::ADD; + m_context << Instruction::SWAP1 << u256(1) << Instruction::ADD; // increment memory offset by 32 - m_context << eth::Instruction::SWAP1 << u256(32) << eth::Instruction::ADD; + m_context << Instruction::SWAP1 << u256(32) << Instruction::ADD; } else { // stack here: memory_end_offset storage_data_offset [storage_byte_offset] memory_offset if (haveByteOffset) - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP3; + m_context << Instruction::DUP3 << Instruction::DUP3; else - m_context << eth::Instruction::DUP2 << u256(0); + m_context << Instruction::DUP2 << u256(0); StorageItem(m_context, *_sourceType.baseType()).retrieveValue(SourceLocation(), true); if (auto baseArray = dynamic_cast<ArrayType const*>(_sourceType.baseType().get())) copyArrayToMemory(*baseArray, _padToWordBoundaries); @@ -471,29 +471,29 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord incrementByteOffset(storageBytes, 2, 3); else { - m_context << eth::Instruction::SWAP1; - m_context << storageSize << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; + m_context << storageSize << Instruction::ADD; + m_context << Instruction::SWAP1; } } // check for loop condition - m_context << eth::Instruction::DUP1 << eth::dupInstruction(haveByteOffset ? 5 : 4); - m_context << eth::Instruction::GT; + m_context << Instruction::DUP1 << dupInstruction(haveByteOffset ? 5 : 4); + m_context << Instruction::GT; m_context.appendConditionalJumpTo(loopStart); // stack here: memory_end_offset storage_data_offset [storage_byte_offset] memory_offset if (haveByteOffset) - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; if (_padToWordBoundaries && baseSize % 32 != 0) { // memory_end_offset - start is the actual length (we want to compute the ceil of). // memory_offset - start is its next multiple of 32, but it might be off by 32. // so we compute: memory_end_offset += (memory_offset - memory_end_offest) & 31 - m_context << eth::Instruction::DUP3 << eth::Instruction::SWAP1 << eth::Instruction::SUB; - m_context << u256(31) << eth::Instruction::AND; - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP2; + m_context << Instruction::DUP3 << Instruction::SWAP1 << Instruction::SUB; + m_context << u256(31) << Instruction::AND; + m_context << Instruction::DUP3 << Instruction::ADD; + m_context << Instruction::SWAP2; } - m_context << loopEnd << eth::Instruction::POP << eth::Instruction::POP; + m_context << loopEnd << Instruction::POP << Instruction::POP; } } @@ -509,20 +509,20 @@ void ArrayUtils::clearArray(ArrayType const& _type) const if (_type.baseType()->isValueType()) solAssert(_type.baseType()->storageSize() <= 1, "Invalid size for value type."); - m_context << eth::Instruction::POP; // remove byte offset + m_context << Instruction::POP; // remove byte offset if (_type.isDynamicallySized()) clearDynamicArray(_type); else if (_type.length() == 0 || _type.baseType()->category() == Type::Category::Mapping) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; else if (_type.baseType()->isValueType() && _type.storageSize() <= 5) { // unroll loop for small arrays @todo choose a good value // Note that we loop over storage slots here, not elements. for (unsigned i = 1; i < _type.storageSize(); ++i) m_context - << u256(0) << eth::Instruction::DUP2 << eth::Instruction::SSTORE - << u256(1) << eth::Instruction::ADD; - m_context << u256(0) << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + << u256(0) << Instruction::DUP2 << Instruction::SSTORE + << u256(1) << Instruction::ADD; + m_context << u256(0) << Instruction::SWAP1 << Instruction::SSTORE; } else if (!_type.baseType()->isValueType() && _type.length() <= 4) { @@ -533,22 +533,22 @@ void ArrayUtils::clearArray(ArrayType const& _type) const m_context << u256(0); StorageItem(m_context, *_type.baseType()).setToZero(SourceLocation(), false); m_context - << eth::Instruction::POP - << u256(_type.baseType()->storageSize()) << eth::Instruction::ADD; + << Instruction::POP + << u256(_type.baseType()->storageSize()) << Instruction::ADD; } m_context << u256(0); StorageItem(m_context, *_type.baseType()).setToZero(SourceLocation(), true); } else { - m_context << eth::Instruction::DUP1 << _type.length(); + m_context << Instruction::DUP1 << _type.length(); convertLengthToSize(_type); - m_context << eth::Instruction::ADD << eth::Instruction::SWAP1; + m_context << Instruction::ADD << Instruction::SWAP1; if (_type.baseType()->storageBytes() < 32) clearStorageLoop(IntegerType(256)); else clearStorageLoop(*_type.baseType()); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } solAssert(m_context.stackHeight() == stackHeightStart - 2, ""); } @@ -561,15 +561,15 @@ void ArrayUtils::clearDynamicArray(ArrayType const& _type) const // fetch length retrieveLength(_type); // set length to zero - m_context << u256(0) << eth::Instruction::DUP3 << eth::Instruction::SSTORE; + m_context << u256(0) << Instruction::DUP3 << Instruction::SSTORE; // Special case: short byte arrays are stored togeher with their length eth::AssemblyItem endTag = m_context.newTag(); if (_type.isByteArray()) { // stack: ref old_length - m_context << eth::Instruction::DUP1 << u256(31) << eth::Instruction::LT; + m_context << Instruction::DUP1 << u256(31) << Instruction::LT; eth::AssemblyItem longByteArray = m_context.appendConditionalJump(); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; m_context.appendJumpTo(endTag); m_context.adjustStackOffset(1); // needed because of jump m_context << longByteArray; @@ -577,11 +577,11 @@ void ArrayUtils::clearDynamicArray(ArrayType const& _type) const // stack: ref old_length convertLengthToSize(_type); // compute data positions - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; CompilerUtils(m_context).computeHashStatic(); // stack: len data_pos - m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2 << eth::Instruction::ADD - << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1 << Instruction::DUP2 << Instruction::ADD + << Instruction::SWAP1; // stack: data_pos_end data_pos if (_type.isByteArray() || _type.baseType()->storageBytes() < 32) clearStorageLoop(IntegerType(256)); @@ -589,7 +589,7 @@ void ArrayUtils::clearDynamicArray(ArrayType const& _type) const clearStorageLoop(*_type.baseType()); // cleanup m_context << endTag; - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } void ArrayUtils::resizeDynamicArray(ArrayType const& _type) const @@ -614,13 +614,13 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _type) const eth::AssemblyItem regularPath = m_context.newTag(); // We start by a large case-distinction about the old and new length of the byte array. - m_context << eth::Instruction::DUP3 << eth::Instruction::SLOAD; + m_context << Instruction::DUP3 << Instruction::SLOAD; // stack: ref new_length current_length ref_value solAssert(m_context.stackHeight() - stackHeightStart == 4 - 2, "3"); - m_context << eth::Instruction::DUP2 << u256(31) << eth::Instruction::LT; + m_context << Instruction::DUP2 << u256(31) << Instruction::LT; eth::AssemblyItem currentIsLong = m_context.appendConditionalJump(); - m_context << eth::Instruction::DUP3 << u256(31) << eth::Instruction::LT; + m_context << Instruction::DUP3 << u256(31) << Instruction::LT; eth::AssemblyItem newIsLong = m_context.appendConditionalJump(); // Here: short -> short @@ -628,17 +628,17 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _type) const // Compute 1 << (256 - 8 * new_size) eth::AssemblyItem shortToShort = m_context.newTag(); m_context << shortToShort; - m_context << eth::Instruction::DUP3 << u256(8) << eth::Instruction::MUL; - m_context << u256(0x100) << eth::Instruction::SUB; - m_context << u256(2) << eth::Instruction::EXP; + m_context << Instruction::DUP3 << u256(8) << Instruction::MUL; + m_context << u256(0x100) << Instruction::SUB; + m_context << u256(2) << Instruction::EXP; // Divide and multiply by that value, clearing bits. - m_context << eth::Instruction::DUP1 << eth::Instruction::SWAP2; - m_context << eth::Instruction::DIV << eth::Instruction::MUL; + m_context << Instruction::DUP1 << Instruction::SWAP2; + m_context << Instruction::DIV << Instruction::MUL; // Insert 2*length. - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP1 << eth::Instruction::ADD; - m_context << eth::Instruction::OR; + m_context << Instruction::DUP3 << Instruction::DUP1 << Instruction::ADD; + m_context << Instruction::OR; // Store. - m_context << eth::Instruction::DUP4 << eth::Instruction::SSTORE; + m_context << Instruction::DUP4 << Instruction::SSTORE; solAssert(m_context.stackHeight() - stackHeightStart == 3 - 2, "3"); m_context.appendJumpTo(resizeEnd); @@ -649,24 +649,24 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _type) const // stack: ref new_length current_length ref_value solAssert(m_context.stackHeight() - stackHeightStart == 4 - 2, "3"); // Zero out lower-order byte. - m_context << u256(0xff) << eth::Instruction::NOT << eth::Instruction::AND; + m_context << u256(0xff) << Instruction::NOT << Instruction::AND; // Store at data location. - m_context << eth::Instruction::DUP4; + m_context << Instruction::DUP4; CompilerUtils(m_context).computeHashStatic(); - m_context << eth::Instruction::SSTORE; + m_context << Instruction::SSTORE; // stack: ref new_length current_length // Store new length: Compule 2*length + 1 and store it. - m_context << eth::Instruction::DUP2 << eth::Instruction::DUP1 << eth::Instruction::ADD; - m_context << u256(1) << eth::Instruction::ADD; + m_context << Instruction::DUP2 << Instruction::DUP1 << Instruction::ADD; + m_context << u256(1) << Instruction::ADD; // stack: ref new_length current_length 2*new_length+1 - m_context << eth::Instruction::DUP4 << eth::Instruction::SSTORE; + m_context << Instruction::DUP4 << Instruction::SSTORE; solAssert(m_context.stackHeight() - stackHeightStart == 3 - 2, "3"); m_context.appendJumpTo(resizeEnd); m_context.adjustStackOffset(1); // we have to do that because of the jumps m_context << currentIsLong; - m_context << eth::Instruction::DUP3 << u256(31) << eth::Instruction::LT; + m_context << Instruction::DUP3 << u256(31) << Instruction::LT; m_context.appendConditionalJumpTo(regularPath); // Here: long -> short @@ -675,51 +675,51 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _type) const // stack: ref new_length current_length ref_value solAssert(m_context.stackHeight() - stackHeightStart == 4 - 2, "3"); - m_context << eth::Instruction::POP << eth::Instruction::DUP3; + m_context << Instruction::POP << Instruction::DUP3; CompilerUtils(m_context).computeHashStatic(); - m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP1; + m_context << Instruction::DUP1 << Instruction::SLOAD << Instruction::SWAP1; // stack: ref new_length current_length first_word data_location - m_context << eth::Instruction::DUP3; + m_context << Instruction::DUP3; convertLengthToSize(_type); - m_context << eth::Instruction::DUP2 << eth::Instruction::ADD << eth::Instruction::SWAP1; + m_context << Instruction::DUP2 << Instruction::ADD << Instruction::SWAP1; // stack: ref new_length current_length first_word data_location_end data_location clearStorageLoop(IntegerType(256)); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; // stack: ref new_length current_length first_word solAssert(m_context.stackHeight() - stackHeightStart == 4 - 2, "3"); m_context.appendJumpTo(shortToShort); m_context << regularPath; // stack: ref new_length current_length ref_value - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } // Change of length for a regular array (i.e. length at location, data at sha3(location)). // stack: ref new_length old_length // store new length - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP2; if (_type.isByteArray()) // For a "long" byte array, store length as 2*length+1 - m_context << eth::Instruction::DUP1 << eth::Instruction::ADD << u256(1) << eth::Instruction::ADD; - m_context<< eth::Instruction::DUP4 << eth::Instruction::SSTORE; + m_context << Instruction::DUP1 << Instruction::ADD << u256(1) << Instruction::ADD; + m_context<< Instruction::DUP4 << Instruction::SSTORE; // skip if size is not reduced - m_context << eth::Instruction::DUP2 << eth::Instruction::DUP2 - << eth::Instruction::ISZERO << eth::Instruction::GT; + m_context << Instruction::DUP2 << Instruction::DUP2 + << Instruction::ISZERO << Instruction::GT; m_context.appendConditionalJumpTo(resizeEnd); // size reduced, clear the end of the array // stack: ref new_length old_length convertLengthToSize(_type); - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP2; convertLengthToSize(_type); // stack: ref new_length old_size new_size // compute data positions - m_context << eth::Instruction::DUP4; + m_context << Instruction::DUP4; CompilerUtils(m_context).computeHashStatic(); // stack: ref new_length old_size new_size data_pos - m_context << eth::Instruction::SWAP2 << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << Instruction::SWAP2 << Instruction::DUP3 << Instruction::ADD; // stack: ref new_length data_pos new_size delete_end - m_context << eth::Instruction::SWAP2 << eth::Instruction::ADD; + m_context << Instruction::SWAP2 << Instruction::ADD; // stack: ref new_length delete_end delete_start if (_type.isByteArray() || _type.baseType()->storageBytes() < 32) clearStorageLoop(IntegerType(256)); @@ -728,7 +728,7 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _type) const m_context << resizeEnd; // cleanup - m_context << eth::Instruction::POP << eth::Instruction::POP << eth::Instruction::POP; + m_context << Instruction::POP << Instruction::POP << Instruction::POP; solAssert(m_context.stackHeight() == stackHeightStart - 2, ""); } @@ -737,35 +737,35 @@ void ArrayUtils::clearStorageLoop(Type const& _type) const unsigned stackHeightStart = m_context.stackHeight(); if (_type.category() == Type::Category::Mapping) { - m_context << eth::Instruction::POP; + m_context << Instruction::POP; return; } // stack: end_pos pos // jump to and return from the loop to allow for duplicate code removal eth::AssemblyItem returnTag = m_context.pushNewTag(); - m_context << eth::Instruction::SWAP2 << eth::Instruction::SWAP1; + m_context << Instruction::SWAP2 << Instruction::SWAP1; // stack: <return tag> end_pos pos eth::AssemblyItem loopStart = m_context.appendJumpToNew(); m_context << loopStart; // check for loop condition - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3 - << eth::Instruction::GT << eth::Instruction::ISZERO; + m_context << Instruction::DUP1 << Instruction::DUP3 + << Instruction::GT << Instruction::ISZERO; eth::AssemblyItem zeroLoopEnd = m_context.newTag(); m_context.appendConditionalJumpTo(zeroLoopEnd); // delete m_context << u256(0); StorageItem(m_context, _type).setToZero(SourceLocation(), false); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; // increment - m_context << u256(1) << eth::Instruction::ADD; + m_context << u256(1) << Instruction::ADD; m_context.appendJumpTo(loopStart); // cleanup m_context << zeroLoopEnd; - m_context << eth::Instruction::POP << eth::Instruction::SWAP1; + m_context << Instruction::POP << Instruction::SWAP1; // "return" - m_context << eth::Instruction::JUMP; + m_context << Instruction::JUMP; m_context << returnTag; solAssert(m_context.stackHeight() == stackHeightStart - 1, ""); @@ -779,17 +779,17 @@ void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType, bool _pad) con { unsigned baseBytes = _arrayType.baseType()->storageBytes(); if (baseBytes == 0) - m_context << eth::Instruction::POP << u256(1); + m_context << Instruction::POP << u256(1); else if (baseBytes <= 16) { unsigned itemsPerSlot = 32 / baseBytes; m_context - << u256(itemsPerSlot - 1) << eth::Instruction::ADD - << u256(itemsPerSlot) << eth::Instruction::SWAP1 << eth::Instruction::DIV; + << u256(itemsPerSlot - 1) << Instruction::ADD + << u256(itemsPerSlot) << Instruction::SWAP1 << Instruction::DIV; } } else - m_context << _arrayType.baseType()->storageSize() << eth::Instruction::MUL; + m_context << _arrayType.baseType()->storageSize() << Instruction::MUL; } else { @@ -799,12 +799,12 @@ void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType, bool _pad) con m_context << _arrayType.baseType()->memoryHeadSize(); else m_context << _arrayType.baseType()->calldataEncodedSize(); - m_context << eth::Instruction::MUL; + m_context << Instruction::MUL; } else if (_pad) - m_context << u256(31) << eth::Instruction::ADD - << u256(32) << eth::Instruction::DUP1 - << eth::Instruction::SWAP2 << eth::Instruction::DIV << eth::Instruction::MUL; + m_context << u256(31) << Instruction::ADD + << u256(32) << Instruction::DUP1 + << Instruction::SWAP2 << Instruction::DIV << Instruction::MUL; } } @@ -814,27 +814,27 @@ void ArrayUtils::retrieveLength(ArrayType const& _arrayType, unsigned _stackDept m_context << _arrayType.length(); else { - m_context << eth::dupInstruction(1 + _stackDepth); + m_context << dupInstruction(1 + _stackDepth); switch (_arrayType.location()) { case DataLocation::CallData: // length is stored on the stack break; case DataLocation::Memory: - m_context << eth::Instruction::MLOAD; + m_context << Instruction::MLOAD; break; case DataLocation::Storage: - m_context << eth::Instruction::SLOAD; + m_context << Instruction::SLOAD; if (_arrayType.isByteArray()) { // Retrieve length both for in-place strings and off-place strings: // Computes (x & (0x100 * (ISZERO (x & 1)) - 1)) / 2 // i.e. for short strings (x & 1 == 0) it does (x & 0xff) / 2 and for long strings it // computes (x & (-1)) / 2, which is equivalent to just x / 2. - m_context << u256(1) << eth::Instruction::DUP2 << u256(1) << eth::Instruction::AND; - m_context << eth::Instruction::ISZERO << u256(0x100) << eth::Instruction::MUL; - m_context << eth::Instruction::SUB << eth::Instruction::AND; - m_context << u256(2) << eth::Instruction::SWAP1 << eth::Instruction::DIV; + m_context << u256(1) << Instruction::DUP2 << u256(1) << Instruction::AND; + m_context << Instruction::ISZERO << u256(0x100) << Instruction::MUL; + m_context << Instruction::SUB << Instruction::AND; + m_context << u256(2) << Instruction::SWAP1 << Instruction::DIV; } break; } @@ -852,34 +852,34 @@ void ArrayUtils::accessIndex(ArrayType const& _arrayType, bool _doBoundsCheck) c ArrayUtils::retrieveLength(_arrayType, 1); // Stack: ref [length] index length // check out-of-bounds access - m_context << eth::Instruction::DUP2 << eth::Instruction::LT << eth::Instruction::ISZERO; + m_context << Instruction::DUP2 << Instruction::LT << Instruction::ISZERO; // out-of-bounds access throws exception m_context.appendConditionalJumpTo(m_context.errorTag()); } if (location == DataLocation::CallData && _arrayType.isDynamicallySized()) // remove length if present - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; // stack: <base_ref> <index> - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; // stack: <index> <base_ref> switch (location) { case DataLocation::Memory: if (_arrayType.isDynamicallySized()) - m_context << u256(32) << eth::Instruction::ADD; + m_context << u256(32) << Instruction::ADD; // fall-through case DataLocation::CallData: if (!_arrayType.isByteArray()) { - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; if (location == DataLocation::CallData) m_context << _arrayType.baseType()->calldataEncodedSize(); else m_context << u256(_arrayType.memoryHeadSize()); - m_context << eth::Instruction::MUL; + m_context << Instruction::MUL; } - m_context << eth::Instruction::ADD; + m_context << Instruction::ADD; break; case DataLocation::Storage: { @@ -887,16 +887,16 @@ void ArrayUtils::accessIndex(ArrayType const& _arrayType, bool _doBoundsCheck) c if (_arrayType.isByteArray()) { // Special case of short byte arrays. - m_context << eth::Instruction::SWAP1; - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD; - m_context << u256(1) << eth::Instruction::AND << eth::Instruction::ISZERO; + m_context << Instruction::SWAP1; + m_context << Instruction::DUP2 << Instruction::SLOAD; + m_context << u256(1) << Instruction::AND << Instruction::ISZERO; // No action needed for short byte arrays. m_context.appendConditionalJumpTo(endTag); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; } if (_arrayType.isDynamicallySized()) CompilerUtils(m_context).computeHashStatic(); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; if (_arrayType.baseType()->storageBytes() <= 16) { // stack: <data_ref> <index> @@ -905,22 +905,22 @@ void ArrayUtils::accessIndex(ArrayType const& _arrayType, bool _doBoundsCheck) c unsigned byteSize = _arrayType.baseType()->storageBytes(); solAssert(byteSize != 0, ""); unsigned itemsPerSlot = 32 / byteSize; - m_context << u256(itemsPerSlot) << eth::Instruction::SWAP2; + m_context << u256(itemsPerSlot) << Instruction::SWAP2; // stack: itemsPerSlot index data_ref m_context - << eth::Instruction::DUP3 << eth::Instruction::DUP3 - << eth::Instruction::DIV << eth::Instruction::ADD + << Instruction::DUP3 << Instruction::DUP3 + << Instruction::DIV << Instruction::ADD // stack: itemsPerSlot index (data_ref + index / itemsPerSlot) - << eth::Instruction::SWAP2 << eth::Instruction::SWAP1 - << eth::Instruction::MOD; + << Instruction::SWAP2 << Instruction::SWAP1 + << Instruction::MOD; if (byteSize != 1) - m_context << u256(byteSize) << eth::Instruction::MUL; + m_context << u256(byteSize) << Instruction::MUL; } else { if (_arrayType.baseType()->storageSize() != 1) - m_context << _arrayType.baseType()->storageSize() << eth::Instruction::MUL; - m_context << eth::Instruction::ADD << u256(0); + m_context << _arrayType.baseType()->storageSize() << Instruction::MUL; + m_context << Instruction::ADD << u256(0); } m_context << endTag; break; @@ -942,27 +942,27 @@ void ArrayUtils::incrementByteOffset(unsigned _byteSize, unsigned _byteOffsetPos // byteOffset = 0; // } if (_byteOffsetPosition > 1) - m_context << eth::swapInstruction(_byteOffsetPosition - 1); - m_context << u256(_byteSize) << eth::Instruction::ADD; + m_context << swapInstruction(_byteOffsetPosition - 1); + m_context << u256(_byteSize) << Instruction::ADD; if (_byteOffsetPosition > 1) - m_context << eth::swapInstruction(_byteOffsetPosition - 1); + m_context << swapInstruction(_byteOffsetPosition - 1); // compute, X := (byteOffset + byteSize - 1) / 32, should be 1 iff byteOffset + bytesize > 32 m_context - << u256(32) << eth::dupInstruction(1 + _byteOffsetPosition) << u256(_byteSize - 1) - << eth::Instruction::ADD << eth::Instruction::DIV; + << u256(32) << dupInstruction(1 + _byteOffsetPosition) << u256(_byteSize - 1) + << Instruction::ADD << Instruction::DIV; // increment storage offset if X == 1 (just add X to it) // stack: X m_context - << eth::swapInstruction(_storageOffsetPosition) << eth::dupInstruction(_storageOffsetPosition + 1) - << eth::Instruction::ADD << eth::swapInstruction(_storageOffsetPosition); + << swapInstruction(_storageOffsetPosition) << dupInstruction(_storageOffsetPosition + 1) + << Instruction::ADD << swapInstruction(_storageOffsetPosition); // stack: X // set source_byte_offset to zero if X == 1 (using source_byte_offset *= 1 - X) - m_context << u256(1) << eth::Instruction::SUB; + m_context << u256(1) << Instruction::SUB; // stack: 1 - X if (_byteOffsetPosition == 1) - m_context << eth::Instruction::MUL; + m_context << Instruction::MUL; else m_context - << eth::dupInstruction(_byteOffsetPosition + 1) << eth::Instruction::MUL - << eth::swapInstruction(_byteOffsetPosition) << eth::Instruction::POP; + << dupInstruction(_byteOffsetPosition + 1) << Instruction::MUL + << swapInstruction(_byteOffsetPosition) << Instruction::POP; } diff --git a/libsolidity/codegen/Compiler.cpp b/libsolidity/codegen/Compiler.cpp index 69e23359..8b718fca 100644 --- a/libsolidity/codegen/Compiler.cpp +++ b/libsolidity/codegen/Compiler.cpp @@ -23,7 +23,7 @@ #include <libsolidity/codegen/Compiler.h> #include <algorithm> #include <boost/range/adaptor/reversed.hpp> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libethcore/ChainOperationParams.h> #include <libevmasm/Assembly.h> #include <libsolidity/inlineasm/AsmCodeGen.h> @@ -92,8 +92,8 @@ void Compiler::compileClone( m_runtimeSub = size_t(runtimeSub.data()); // stack contains sub size - m_context << eth::Instruction::DUP1 << runtimeSub << u256(0) << eth::Instruction::CODECOPY; - m_context << u256(0) << eth::Instruction::RETURN; + m_context << Instruction::DUP1 << runtimeSub << u256(0) << Instruction::CODECOPY; + m_context << u256(0) << Instruction::RETURN; appendFunctionsWithoutCode(); @@ -164,8 +164,8 @@ void Compiler::packIntoContractCreator(ContractDefinition const& _contract, Comp m_runtimeSub = size_t(runtimeSub.data()); // stack contains sub size - m_context << eth::Instruction::DUP1 << runtimeSub << u256(0) << eth::Instruction::CODECOPY; - m_context << u256(0) << eth::Instruction::RETURN; + m_context << Instruction::DUP1 << runtimeSub << u256(0) << Instruction::CODECOPY; + m_context << u256(0) << Instruction::RETURN; // note that we have to include the functions again because of absolute jump labels appendFunctionsWithoutCode(); @@ -208,15 +208,15 @@ void Compiler::appendConstructor(FunctionDefinition const& _constructor) // argument size is dynamic, use CODESIZE to determine it m_context.appendProgramSize(); // program itself // CODESIZE is program plus manually added arguments - m_context << eth::Instruction::CODESIZE << eth::Instruction::SUB; + m_context << Instruction::CODESIZE << Instruction::SUB; } else m_context << u256(argumentSize); // stack: <memptr> <argument size> - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; m_context.appendProgramSize(); - m_context << eth::Instruction::DUP4 << eth::Instruction::CODECOPY; - m_context << eth::Instruction::DUP2 << eth::Instruction::ADD; + m_context << Instruction::DUP4 << Instruction::CODECOPY; + m_context << Instruction::DUP2 << Instruction::ADD; CompilerUtils(m_context).storeFreeMemoryPointer(); // stack: <memptr> appendCalldataUnpacker(FunctionType(_constructor).parameterTypes(), true); @@ -235,7 +235,7 @@ void Compiler::appendFunctionSelector(ContractDefinition const& _contract) // ether with constant gas if (interfaceFunctions.size() > 5 || fallback) { - m_context << eth::Instruction::CALLDATASIZE << eth::Instruction::ISZERO; + m_context << Instruction::CALLDATASIZE << Instruction::ISZERO; m_context.appendConditionalJumpTo(notFound); } @@ -247,7 +247,7 @@ void Compiler::appendFunctionSelector(ContractDefinition const& _contract) for (auto const& it: interfaceFunctions) { callDataUnpackerEntryPoints.insert(std::make_pair(it.first, m_context.newTag())); - m_context << eth::dupInstruction(1) << u256(FixedHash<4>::Arith(it.first)) << eth::Instruction::EQ; + m_context << dupInstruction(1) << u256(FixedHash<4>::Arith(it.first)) << Instruction::EQ; m_context.appendConditionalJumpTo(callDataUnpackerEntryPoints.at(it.first)); } m_context.appendJumpTo(notFound); @@ -264,7 +264,7 @@ void Compiler::appendFunctionSelector(ContractDefinition const& _contract) // Reject invalid library calls and ether sent to a library. m_context.appendJumpTo(m_context.errorTag()); else - m_context << eth::Instruction::STOP; // function not found + m_context << Instruction::STOP; // function not found for (auto const& it: interfaceFunctions) { @@ -288,7 +288,7 @@ void Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool //@todo this does not yet support nested dynamic arrays // Retain the offset pointer as base_offset, the point from which the data offsets are computed. - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; for (TypePointer const& parameterType: _typeParameters) { // stack: v1 v2 ... v(k-1) base_offset current_offset @@ -309,15 +309,15 @@ void Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool if (arrayType.isDynamicallySized()) { // compute data pointer - m_context << eth::Instruction::DUP1 << eth::Instruction::MLOAD; - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP2 << eth::Instruction::SWAP1; - m_context << u256(0x20) << eth::Instruction::ADD; + m_context << Instruction::DUP1 << Instruction::MLOAD; + m_context << Instruction::DUP3 << Instruction::ADD; + m_context << Instruction::SWAP2 << Instruction::SWAP1; + m_context << u256(0x20) << Instruction::ADD; } else { - m_context << eth::Instruction::DUP1; - m_context << u256(arrayType.calldataEncodedSize(true)) << eth::Instruction::ADD; + m_context << Instruction::DUP1; + m_context << u256(arrayType.calldataEncodedSize(true)) << Instruction::ADD; } } else @@ -329,19 +329,19 @@ void Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool // put on stack: data_pointer length CompilerUtils(m_context).loadFromMemoryDynamic(IntegerType(256), !_fromMemory); // stack: base_offset data_offset next_pointer - m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << Instruction::SWAP1 << Instruction::DUP3 << Instruction::ADD; // stack: base_offset next_pointer data_pointer // retrieve length CompilerUtils(m_context).loadFromMemoryDynamic(IntegerType(256), !_fromMemory, true); // stack: base_offset next_pointer length data_pointer - m_context << eth::Instruction::SWAP2; + m_context << Instruction::SWAP2; // stack: base_offset data_pointer length next_pointer } else { // leave the pointer on the stack - m_context << eth::Instruction::DUP1; - m_context << u256(calldataType->calldataEncodedSize()) << eth::Instruction::ADD; + m_context << Instruction::DUP1; + m_context << u256(calldataType->calldataEncodedSize()) << Instruction::ADD; } if (arrayType.location() == DataLocation::Memory) { @@ -355,7 +355,7 @@ void Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool } // move base_offset up CompilerUtils(m_context).moveToStackTop(1 + arrayType.sizeOnStack()); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; } } else @@ -363,18 +363,18 @@ void Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool solAssert(!type->isDynamicallySized(), "Unknown dynamically sized type: " + type->toString()); CompilerUtils(m_context).loadFromMemoryDynamic(*type, !_fromMemory, true); CompilerUtils(m_context).moveToStackTop(1 + type->sizeOnStack()); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; } // stack: v1 v2 ... v(k-1) v(k) base_offset mem_offset } - m_context << eth::Instruction::POP << eth::Instruction::POP; + m_context << Instruction::POP << Instruction::POP; } void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters, bool _isLibrary) { CompilerUtils utils(m_context); if (_typeParameters.empty()) - m_context << eth::Instruction::STOP; + m_context << Instruction::STOP; else { utils.fetchFreeMemoryPointer(); @@ -382,7 +382,7 @@ void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters, bool // its data to add the needed parts and we avoid a memory copy. utils.encodeToMemory(_typeParameters, _typeParameters, true, false, _isLibrary); utils.toSizeAfterFreeMemoryPointer(); - m_context << eth::Instruction::RETURN; + m_context << Instruction::RETURN; } } @@ -476,12 +476,12 @@ bool Compiler::visit(FunctionDefinition const& _function) while (stackLayout.back() != int(stackLayout.size() - 1)) if (stackLayout.back() < 0) { - m_context << eth::Instruction::POP; + m_context << Instruction::POP; stackLayout.pop_back(); } else { - m_context << eth::swapInstruction(stackLayout.size() - stackLayout.back() - 1); + m_context << swapInstruction(stackLayout.size() - stackLayout.back() - 1); swap(stackLayout[stackLayout.back()], stackLayout.back()); } //@todo assert that everything is in place now @@ -532,7 +532,7 @@ bool Compiler::visit(InlineAssembly const& _inlineAssembly) errinfo_comment("Stack too deep, try removing local variables.") ); for (unsigned i = 0; i < variable->type()->sizeOnStack(); ++i) - _assembly.append(eth::dupInstruction(stackDiff)); + _assembly.append(dupInstruction(stackDiff)); } else { @@ -572,8 +572,8 @@ bool Compiler::visit(InlineAssembly const& _inlineAssembly) errinfo_comment("Stack too deep, try removing local variables.") ); for (unsigned i = 0; i < size; ++i) { - _assembly.append(eth::swapInstruction(stackDiff)); - _assembly.append(eth::Instruction::POP); + _assembly.append(swapInstruction(stackDiff)); + _assembly.append(Instruction::POP); } } return true; @@ -588,7 +588,7 @@ bool Compiler::visit(IfStatement const& _ifStatement) StackHeightChecker checker(m_context); CompilerContext::LocationSetter locationSetter(m_context, _ifStatement); compileExpression(_ifStatement.condition()); - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; eth::AssemblyItem falseTag = m_context.appendConditionalJump(); eth::AssemblyItem endTag = falseTag; _ifStatement.trueStatement().accept(*this); @@ -615,7 +615,7 @@ bool Compiler::visit(WhileStatement const& _whileStatement) m_context << loopStart; compileExpression(_whileStatement.condition()); - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; m_context.appendConditionalJumpTo(loopEnd); _whileStatement.body().accept(*this); @@ -649,7 +649,7 @@ bool Compiler::visit(ForStatement const& _forStatement) if (_forStatement.condition()) { compileExpression(*_forStatement.condition()); - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; m_context.appendConditionalJumpTo(loopEnd); } @@ -710,7 +710,7 @@ bool Compiler::visit(Return const& _return) CompilerUtils(m_context).moveToStackVariable(*retVariable); } for (unsigned i = 0; i < m_stackCleanupForReturn; ++i) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; m_context.appendJumpTo(m_returnTag); m_context.adjustStackOffset(m_stackCleanupForReturn); return false; @@ -831,7 +831,7 @@ void Compiler::appendModifierOrFunctionCode() modifier.body().accept(*this); for (unsigned i = 0; i < c_stackSurplus; ++i) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; m_stackCleanupForReturn -= c_stackSurplus; } } @@ -855,20 +855,20 @@ eth::Assembly Compiler::cloneRuntime() { eth::EVMSchedule schedule; eth::Assembly a; - a << eth::Instruction::CALLDATASIZE; - a << u256(0) << eth::Instruction::DUP1 << eth::Instruction::CALLDATACOPY; + a << Instruction::CALLDATASIZE; + a << u256(0) << Instruction::DUP1 << Instruction::CALLDATACOPY; //@todo adjust for larger return values, make this dynamic. - a << u256(0x20) << u256(0) << eth::Instruction::CALLDATASIZE; + a << u256(0x20) << u256(0) << Instruction::CALLDATASIZE; a << u256(0); // this is the address which has to be substituted by the linker. //@todo implement as special "marker" AssemblyItem. a << u256("0xcafecafecafecafecafecafecafecafecafecafe"); - a << u256(schedule.callGas + 10) << eth::Instruction::GAS << eth::Instruction::SUB; - a << eth::Instruction::DELEGATECALL; + a << u256(schedule.callGas + 10) << Instruction::GAS << Instruction::SUB; + a << Instruction::DELEGATECALL; //Propagate error condition (if DELEGATECALL pushes 0 on stack). - a << eth::Instruction::ISZERO; + a << Instruction::ISZERO; a.appendJumpI(a.errorTag()); //@todo adjust for larger return values, make this dynamic. - a << u256(0x20) << u256(0) << eth::Instruction::RETURN; + a << u256(0x20) << u256(0) << Instruction::RETURN; return a; } diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp index 9e2405cc..7810288e 100644 --- a/libsolidity/codegen/CompilerContext.cpp +++ b/libsolidity/codegen/CompilerContext.cpp @@ -166,7 +166,7 @@ pair<u256, unsigned> CompilerContext::storageLocationOfVariable(const Declaratio CompilerContext& CompilerContext::appendJump(eth::AssemblyItem::JumpType _jumpType) { - eth::AssemblyItem item(eth::Instruction::JUMP); + eth::AssemblyItem item(Instruction::JUMP); item.setJumpType(_jumpType); return *this << item; } @@ -182,7 +182,7 @@ void CompilerContext::resetVisitedNodes(ASTNode const* _node) void CompilerContext::injectVersionStampIntoSub(size_t _subIndex) { eth::Assembly& sub = m_asm.sub(_subIndex); - sub.injectStart(eth::Instruction::POP); + sub.injectStart(Instruction::POP); sub.injectStart(fromBigEndian<u256>(binaryVersion())); } diff --git a/libsolidity/codegen/CompilerContext.h b/libsolidity/codegen/CompilerContext.h index bd8fc295..9368dbcf 100644 --- a/libsolidity/codegen/CompilerContext.h +++ b/libsolidity/codegen/CompilerContext.h @@ -25,7 +25,7 @@ #include <ostream> #include <stack> #include <utility> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libevmasm/Assembly.h> #include <libsolidity/ast/ASTForward.h> #include <libsolidity/ast/Types.h> @@ -126,7 +126,7 @@ public: /// Append elements to the current instruction list and adjust @a m_stackOffset. CompilerContext& operator<<(eth::AssemblyItem const& _item) { m_asm.append(_item); return *this; } - CompilerContext& operator<<(eth::Instruction _instruction) { m_asm.append(_instruction); return *this; } + CompilerContext& operator<<(Instruction _instruction) { m_asm.append(_instruction); return *this; } CompilerContext& operator<<(u256 const& _value) { m_asm.append(_value); return *this; } CompilerContext& operator<<(bytes const& _data) { m_asm.append(_data); return *this; } diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp index bd0857f6..36ed480e 100644 --- a/libsolidity/codegen/CompilerUtils.cpp +++ b/libsolidity/codegen/CompilerUtils.cpp @@ -22,7 +22,7 @@ #include <libsolidity/codegen/CompilerUtils.h> #include <libsolidity/ast/AST.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libsolidity/codegen/ArrayUtils.h> #include <libsolidity/codegen/LValue.h> @@ -45,26 +45,26 @@ void CompilerUtils::initialiseFreeMemoryPointer() void CompilerUtils::fetchFreeMemoryPointer() { - m_context << u256(freeMemoryPointer) << eth::Instruction::MLOAD; + m_context << u256(freeMemoryPointer) << Instruction::MLOAD; } void CompilerUtils::storeFreeMemoryPointer() { - m_context << u256(freeMemoryPointer) << eth::Instruction::MSTORE; + m_context << u256(freeMemoryPointer) << Instruction::MSTORE; } void CompilerUtils::allocateMemory() { fetchFreeMemoryPointer(); - m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2 << eth::Instruction::ADD; + m_context << Instruction::SWAP1 << Instruction::DUP2 << Instruction::ADD; storeFreeMemoryPointer(); } void CompilerUtils::toSizeAfterFreeMemoryPointer() { fetchFreeMemoryPointer(); - m_context << eth::Instruction::DUP1 << eth::Instruction::SWAP2 << eth::Instruction::SUB; - m_context << eth::Instruction::SWAP1; + m_context << Instruction::DUP1 << Instruction::SWAP2 << Instruction::SUB; + m_context << Instruction::SWAP1; } unsigned CompilerUtils::loadFromMemory( @@ -87,7 +87,7 @@ void CompilerUtils::loadFromMemoryDynamic( ) { if (_keepUpdatedMemoryOffset) - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; if (auto arrayType = dynamic_cast<ArrayType const*>(&_type)) { @@ -95,7 +95,7 @@ void CompilerUtils::loadFromMemoryDynamic( solAssert(!_fromCalldata, ""); solAssert(_padToWordBoundaries, ""); if (_keepUpdatedMemoryOffset) - m_context << arrayType->memorySize() << eth::Instruction::ADD; + m_context << arrayType->memorySize() << Instruction::ADD; } else { @@ -104,7 +104,7 @@ void CompilerUtils::loadFromMemoryDynamic( { // update memory counter moveToStackTop(_type.sizeOnStack()); - m_context << u256(numBytes) << eth::Instruction::ADD; + m_context << u256(numBytes) << Instruction::ADD; } } } @@ -113,7 +113,7 @@ void CompilerUtils::storeInMemory(unsigned _offset) { unsigned numBytes = prepareMemoryStore(IntegerType(256), true); if (numBytes > 0) - m_context << u256(_offset) << eth::Instruction::MSTORE; + m_context << u256(_offset) << Instruction::MSTORE; } void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBoundaries) @@ -125,13 +125,13 @@ void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBound } else if (auto str = dynamic_cast<StringLiteralType const*>(&_type)) { - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; storeStringData(bytesConstRef(str->value())); if (_padToWordBoundaries) m_context << u256(((str->value().size() + 31) / 32) * 32); else m_context << u256(str->value().size()); - m_context << eth::Instruction::ADD; + m_context << Instruction::ADD; } else { @@ -142,8 +142,8 @@ void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBound _type.sizeOnStack() == 1, "Memory store of types with stack size != 1 not implemented." ); - m_context << eth::Instruction::DUP2 << eth::Instruction::MSTORE; - m_context << u256(numBytes) << eth::Instruction::ADD; + m_context << Instruction::DUP2 << Instruction::MSTORE; + m_context << u256(numBytes) << Instruction::ADD; } } } @@ -168,7 +168,7 @@ void CompilerUtils::encodeToMemory( // of the ith dynamic parameter, which is filled once the dynamic parts are processed. // store memory start pointer - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; unsigned argSize = CompilerUtils::sizeOnStack(_givenTypes); unsigned stackPos = 0; // advances through the argument values @@ -180,7 +180,7 @@ void CompilerUtils::encodeToMemory( if (targetType->isDynamicallySized() && !_copyDynamicDataInPlace) { // leave end_of_mem as dyn head pointer - m_context << eth::Instruction::DUP1 << u256(32) << eth::Instruction::ADD; + m_context << Instruction::DUP1 << u256(32) << Instruction::ADD; dynPointers++; } else @@ -222,10 +222,10 @@ void CompilerUtils::encodeToMemory( if (targetType->isDynamicallySized() && !_copyDynamicDataInPlace) { // copy tail pointer (=mem_end - mem_start) to memory - m_context << eth::dupInstruction(2 + dynPointers) << eth::Instruction::DUP2; - m_context << eth::Instruction::SUB; - m_context << eth::dupInstruction(2 + dynPointers - thisDynPointer); - m_context << eth::Instruction::MSTORE; + m_context << dupInstruction(2 + dynPointers) << Instruction::DUP2; + m_context << Instruction::SUB; + m_context << dupInstruction(2 + dynPointers - thisDynPointer); + m_context << Instruction::MSTORE; // stack: ... <end_of_mem> if (_givenTypes[i]->category() == Type::Category::StringLiteral) { @@ -243,13 +243,13 @@ void CompilerUtils::encodeToMemory( copyToStackTop(argSize - stackPos + dynPointers + 2, arrayType.sizeOnStack()); // stack: ... <end_of_mem> <value...> // copy length to memory - m_context << eth::dupInstruction(1 + arrayType.sizeOnStack()); + m_context << dupInstruction(1 + arrayType.sizeOnStack()); ArrayUtils(m_context).retrieveLength(arrayType, 1); // stack: ... <end_of_mem> <value...> <end_of_mem'> <length> storeInMemoryDynamic(IntegerType(256), true); // stack: ... <end_of_mem> <value...> <end_of_mem''> // copy the new memory pointer - m_context << eth::swapInstruction(arrayType.sizeOnStack() + 1) << eth::Instruction::POP; + m_context << swapInstruction(arrayType.sizeOnStack() + 1) << Instruction::POP; // stack: ... <end_of_mem''> <value...> // copy data part ArrayUtils(m_context).copyArrayToMemory(arrayType, _padToWordBoundaries); @@ -262,7 +262,7 @@ void CompilerUtils::encodeToMemory( } // remove unneeded stack elements (and retain memory pointer) - m_context << eth::swapInstruction(argSize + dynPointers + 1); + m_context << swapInstruction(argSize + dynPointers + 1); popStackSlots(argSize + dynPointers + 1); } @@ -272,11 +272,11 @@ void CompilerUtils::zeroInitialiseMemoryArray(ArrayType const& _type) m_context << repeat; pushZeroValue(*_type.baseType()); storeInMemoryDynamic(*_type.baseType()); - m_context << eth::Instruction::SWAP1 << u256(1) << eth::Instruction::SWAP1; - m_context << eth::Instruction::SUB << eth::Instruction::SWAP1; - m_context << eth::Instruction::DUP2; + m_context << Instruction::SWAP1 << u256(1) << Instruction::SWAP1; + m_context << Instruction::SUB << Instruction::SWAP1; + m_context << Instruction::DUP2; m_context.appendConditionalJumpTo(repeat); - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; } void CompilerUtils::memoryCopy() @@ -284,16 +284,16 @@ void CompilerUtils::memoryCopy() // Stack here: size target source // stack for call: outsize target size source value contract gas //@TODO do not use ::CALL if less than 32 bytes? - m_context << eth::Instruction::DUP3 << eth::Instruction::SWAP1; + m_context << Instruction::DUP3 << Instruction::SWAP1; m_context << u256(0) << u256(identityContractAddress); // compute gas costs - m_context << u256(32) << eth::Instruction::DUP5 << u256(31) << eth::Instruction::ADD; + m_context << u256(32) << Instruction::DUP5 << u256(31) << Instruction::ADD; static unsigned c_identityGas = 3; static unsigned c_identityWordGas = 15; - m_context << eth::Instruction::DIV << u256(c_identityWordGas) << eth::Instruction::MUL; - m_context << u256(c_identityGas) << eth::Instruction::ADD; - m_context << eth::Instruction::CALL; - m_context << eth::Instruction::POP; // ignore return value + m_context << Instruction::DIV << u256(c_identityWordGas) << Instruction::MUL; + m_context << u256(c_identityGas) << Instruction::ADD; + m_context << Instruction::CALL; + m_context << Instruction::POP; // ignore return value } void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetType, bool _cleanupNeeded) @@ -317,7 +317,7 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp // conversion from bytes to integer. no need to clean the high bit // only to shift right because of opposite alignment IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType); - m_context << (u256(1) << (256 - typeOnStack.numBytes() * 8)) << eth::Instruction::SWAP1 << eth::Instruction::DIV; + m_context << (u256(1) << (256 - typeOnStack.numBytes() * 8)) << Instruction::SWAP1 << Instruction::DIV; if (targetIntegerType.numBits() < typeOnStack.numBytes() * 8) convertType(IntegerType(typeOnStack.numBytes() * 8), _targetType, _cleanupNeeded); } @@ -329,12 +329,12 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp if (targetType.numBytes() < typeOnStack.numBytes()) { if (targetType.numBytes() == 0) - m_context << eth::Instruction::DUP1 << eth::Instruction::XOR; + m_context << Instruction::DUP1 << Instruction::XOR; else { m_context << (u256(1) << (256 - targetType.numBytes() * 8)); - m_context << eth::Instruction::DUP1 << eth::Instruction::SWAP2; - m_context << eth::Instruction::DIV << eth::Instruction::MUL; + m_context << Instruction::DUP1 << Instruction::SWAP2; + m_context << Instruction::DIV << Instruction::MUL; } } } @@ -356,7 +356,7 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp if (auto typeOnStack = dynamic_cast<IntegerType const*>(&_typeOnStack)) if (targetBytesType.numBytes() * 8 > typeOnStack->numBits()) cleanHigherOrderBits(*typeOnStack); - m_context << (u256(1) << (256 - targetBytesType.numBytes() * 8)) << eth::Instruction::MUL; + m_context << (u256(1) << (256 - targetBytesType.numBytes() * 8)) << Instruction::MUL; } else if (targetTypeCategory == Type::Category::Enum) // just clean @@ -406,7 +406,7 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp m_context << storageSize; allocateMemory(); // stack: mempos - m_context << eth::Instruction::DUP1 << u256(data.size()); + m_context << Instruction::DUP1 << u256(data.size()); storeInMemoryDynamic(IntegerType(256)); // stack: mempos datapos storeStringData(data); @@ -445,18 +445,18 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp // allocate memory // stack: <source ref> (variably sized) <length> - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; ArrayUtils(m_context).convertLengthToSize(targetType, true); // stack: <source ref> (variably sized) <length> <size> if (targetType.isDynamicallySized()) - m_context << u256(0x20) << eth::Instruction::ADD; + m_context << u256(0x20) << Instruction::ADD; allocateMemory(); // stack: <source ref> (variably sized) <length> <mem start> - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; moveIntoStack(2 + stackSize); if (targetType.isDynamicallySized()) { - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP2; storeInMemoryDynamic(IntegerType(256)); } // stack: <mem start> <source ref> (variably sized) <length> <mem data pos> @@ -468,12 +468,12 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp } else { - m_context << u256(0) << eth::Instruction::SWAP1; + m_context << u256(0) << Instruction::SWAP1; // stack: <mem start> <source ref> (variably sized) <length> <counter> <mem data pos> auto repeat = m_context.newTag(); m_context << repeat; - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP3; - m_context << eth::Instruction::LT << eth::Instruction::ISZERO; + m_context << Instruction::DUP3 << Instruction::DUP3; + m_context << Instruction::LT << Instruction::ISZERO; auto loopEnd = m_context.appendConditionalJump(); copyToStackTop(3 + stackSize, stackSize); copyToStackTop(2 + stackSize, 1); @@ -482,11 +482,11 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp StorageItem(m_context, *typeOnStack.baseType()).retrieveValue(SourceLocation(), true); convertType(*typeOnStack.baseType(), *targetType.baseType(), _cleanupNeeded); storeInMemoryDynamic(*targetType.baseType(), true); - m_context << eth::Instruction::SWAP1 << u256(1) << eth::Instruction::ADD; - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1 << u256(1) << Instruction::ADD; + m_context << Instruction::SWAP1; m_context.appendJumpTo(repeat); m_context << loopEnd; - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } // stack: <mem start> <source ref> (variably sized) <length> <mem data pos updated> popStackSlots(2 + stackSize); @@ -540,14 +540,14 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp // stack: <source ref> m_context << typeOnStack.memorySize(); allocateMemory(); - m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2; + m_context << Instruction::SWAP1 << Instruction::DUP2; // stack: <memory ptr> <source ref> <memory ptr> for (auto const& member: typeOnStack.members(nullptr)) { if (!member.type->canLiveOutsideStorage()) continue; pair<u256, unsigned> const& offsets = typeOnStack.storageOffsetsOfMember(member.name); - m_context << offsets.first << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << offsets.first << Instruction::DUP3 << Instruction::ADD; m_context << u256(offsets.second); StorageItem(m_context, *member.type).retrieveValue(SourceLocation(), true); TypePointer targetMemberType = targetType.memberType(member.name); @@ -555,7 +555,7 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp convertType(*member.type, *targetMemberType, true); storeInMemoryDynamic(*targetMemberType, true); } - m_context << eth::Instruction::POP << eth::Instruction::POP; + m_context << Instruction::POP << Instruction::POP; } break; case DataLocation::CallData: @@ -602,13 +602,13 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp // Move it back into its place. for (unsigned j = 0; j < min(sourceSize, targetSize); ++j) m_context << - eth::swapInstruction(depth + targetSize - sourceSize) << - eth::Instruction::POP; + swapInstruction(depth + targetSize - sourceSize) << + Instruction::POP; // Value shrank for (unsigned j = targetSize; j < sourceSize; ++j) { moveToStackTop(depth - 1, 1); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } // Value grew if (targetSize > sourceSize) @@ -639,7 +639,7 @@ void CompilerUtils::pushZeroValue(Type const& _type) m_context << u256(max(32u, _type.calldataEncodedSize())); allocateMemory(); - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; if (auto structType = dynamic_cast<StructType const*>(&_type)) for (auto const& member: structType->members(nullptr)) @@ -657,7 +657,7 @@ void CompilerUtils::pushZeroValue(Type const& _type) } else if (arrayType->length() > 0) { - m_context << arrayType->length() << eth::Instruction::SWAP1; + m_context << arrayType->length() << Instruction::SWAP1; // stack: items_to_do memory_pos zeroInitialiseMemoryArray(*arrayType); // stack: updated_memory_pos @@ -667,7 +667,7 @@ void CompilerUtils::pushZeroValue(Type const& _type) solAssert(false, "Requested initialisation for unknown type: " + _type.toString()); // remove the updated memory pointer - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } void CompilerUtils::moveToStackVariable(VariableDeclaration const& _variable) @@ -683,14 +683,14 @@ void CompilerUtils::moveToStackVariable(VariableDeclaration const& _variable) errinfo_comment("Stack too deep, try removing local variables.") ); for (unsigned i = 0; i < size; ++i) - m_context << eth::swapInstruction(stackPosition - size + 1) << eth::Instruction::POP; + m_context << swapInstruction(stackPosition - size + 1) << Instruction::POP; } void CompilerUtils::copyToStackTop(unsigned _stackDepth, unsigned _itemSize) { solAssert(_stackDepth <= 16, "Stack too deep, try removing local variables."); for (unsigned i = 0; i < _itemSize; ++i) - m_context << eth::dupInstruction(_stackDepth); + m_context << dupInstruction(_stackDepth); } void CompilerUtils::moveToStackTop(unsigned _stackDepth, unsigned _itemSize) @@ -712,14 +712,14 @@ void CompilerUtils::rotateStackUp(unsigned _items) { solAssert(_items - 1 <= 16, "Stack too deep, try removing local variables."); for (unsigned i = 1; i < _items; ++i) - m_context << eth::swapInstruction(_items - i); + m_context << swapInstruction(_items - i); } void CompilerUtils::rotateStackDown(unsigned _items) { solAssert(_items - 1 <= 16, "Stack too deep, try removing local variables."); for (unsigned i = 1; i < _items; ++i) - m_context << eth::swapInstruction(i); + m_context << swapInstruction(i); } void CompilerUtils::popStackElement(Type const& _type) @@ -730,7 +730,7 @@ void CompilerUtils::popStackElement(Type const& _type) void CompilerUtils::popStackSlots(size_t _amount) { for (size_t i = 0; i < _amount; ++i) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } unsigned CompilerUtils::sizeOnStack(vector<shared_ptr<Type const>> const& _variableTypes) @@ -744,7 +744,7 @@ unsigned CompilerUtils::sizeOnStack(vector<shared_ptr<Type const>> const& _varia void CompilerUtils::computeHashStatic() { storeInMemory(0); - m_context << u256(32) << u256(0) << eth::Instruction::SHA3; + m_context << u256(32) << u256(0) << Instruction::SHA3; } void CompilerUtils::storeStringData(bytesConstRef _data) @@ -758,14 +758,14 @@ void CompilerUtils::storeStringData(bytesConstRef _data) m_context << h256::Arith(h256(_data.cropped(i), h256::AlignLeft)); storeInMemoryDynamic(IntegerType(256)); } - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else { // stack: mempos mempos_data m_context.appendData(_data.toBytes()); - m_context << u256(_data.size()) << eth::Instruction::SWAP2; - m_context << eth::Instruction::CODECOPY; + m_context << u256(_data.size()) << Instruction::SWAP2; + m_context << Instruction::CODECOPY; } } @@ -774,18 +774,18 @@ unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCallda unsigned numBytes = _type.calldataEncodedSize(_padToWordBoundaries); bool leftAligned = _type.category() == Type::Category::FixedBytes; if (numBytes == 0) - m_context << eth::Instruction::POP << u256(0); + m_context << Instruction::POP << u256(0); else { solAssert(numBytes <= 32, "Static memory load of more than 32 bytes requested."); - m_context << (_fromCalldata ? eth::Instruction::CALLDATALOAD : eth::Instruction::MLOAD); + m_context << (_fromCalldata ? Instruction::CALLDATALOAD : Instruction::MLOAD); if (numBytes != 32) { // add leading or trailing zeros by dividing/multiplying depending on alignment u256 shiftFactor = u256(1) << ((32 - numBytes) * 8); - m_context << shiftFactor << eth::Instruction::SWAP1 << eth::Instruction::DIV; + m_context << shiftFactor << Instruction::SWAP1 << Instruction::DIV; if (leftAligned) - m_context << shiftFactor << eth::Instruction::MUL; + m_context << shiftFactor << Instruction::MUL; } } @@ -797,9 +797,9 @@ void CompilerUtils::cleanHigherOrderBits(IntegerType const& _typeOnStack) if (_typeOnStack.numBits() == 256) return; else if (_typeOnStack.isSigned()) - m_context << u256(_typeOnStack.numBits() / 8 - 1) << eth::Instruction::SIGNEXTEND; + m_context << u256(_typeOnStack.numBits() / 8 - 1) << Instruction::SIGNEXTEND; else - m_context << ((u256(1) << _typeOnStack.numBits()) - 1) << eth::Instruction::AND; + m_context << ((u256(1) << _typeOnStack.numBits()) - 1) << Instruction::AND; } unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWordBoundaries) const @@ -807,13 +807,13 @@ unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWordBou unsigned numBytes = _type.calldataEncodedSize(_padToWordBoundaries); bool leftAligned = _type.category() == Type::Category::FixedBytes; if (numBytes == 0) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; else { solAssert(numBytes <= 32, "Memory store of more than 32 bytes requested."); if (numBytes != 32 && !leftAligned && !_padToWordBoundaries) // shift the value accordingly before storing - m_context << (u256(1) << ((32 - numBytes) * 8)) << eth::Instruction::MUL; + m_context << (u256(1) << ((32 - numBytes) * 8)) << Instruction::MUL; } return numBytes; } diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp index a17ec2f6..ed36fb24 100644 --- a/libsolidity/codegen/ExpressionCompiler.cpp +++ b/libsolidity/codegen/ExpressionCompiler.cpp @@ -75,7 +75,7 @@ void ExpressionCompiler::appendConstStateVariableAccessor(VariableDeclaration co utils().convertType(*_varDecl.value()->annotation().type, *_varDecl.annotation().type); // append return - m_context << eth::dupInstruction(_varDecl.annotation().type->sizeOnStack() + 1); + m_context << dupInstruction(_varDecl.annotation().type->sizeOnStack() + 1); m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction); } @@ -103,13 +103,13 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& "Accessors for mapping with dynamically-sized keys not yet implemented." ); // pop offset - m_context << eth::Instruction::POP; + m_context << Instruction::POP; // move storage offset to memory. utils().storeInMemory(32); // move key to memory. utils().copyToStackTop(paramTypes.size() - i, 1); utils().storeInMemory(0); - m_context << u256(64) << u256(0) << eth::Instruction::SHA3; + m_context << u256(64) << u256(0) << Instruction::SHA3; // push offset m_context << u256(0); returnType = mappingType->valueType(); @@ -117,7 +117,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& else if (auto arrayType = dynamic_cast<ArrayType const*>(returnType.get())) { // pop offset - m_context << eth::Instruction::POP; + m_context << Instruction::POP; utils().copyToStackTop(paramTypes.size() - i + 1, 1); ArrayUtils(m_context).accessIndex(*arrayType); returnType = arrayType->baseType(); @@ -127,12 +127,12 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& } // remove index arguments. if (paramTypes.size() == 1) - m_context << eth::Instruction::SWAP2 << eth::Instruction::POP << eth::Instruction::SWAP1; + m_context << Instruction::SWAP2 << Instruction::POP << Instruction::SWAP1; else if (paramTypes.size() >= 2) { - m_context << eth::swapInstruction(paramTypes.size()); - m_context << eth::Instruction::POP; - m_context << eth::swapInstruction(paramTypes.size()); + m_context << swapInstruction(paramTypes.size()); + m_context << Instruction::POP; + m_context << swapInstruction(paramTypes.size()); utils().popStackSlots(paramTypes.size() - 1); } unsigned retSizeOnStack = 0; @@ -141,7 +141,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& if (StructType const* structType = dynamic_cast<StructType const*>(returnType.get())) { // remove offset - m_context << eth::Instruction::POP; + m_context << Instruction::POP; auto const& names = accessorType.returnParameterNames(); // struct for (size_t i = 0; i < names.size(); ++i) @@ -152,7 +152,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& if (!arrayType->isByteArray()) continue; pair<u256, unsigned> const& offsets = structType->storageOffsetsOfMember(names[i]); - m_context << eth::Instruction::DUP1 << u256(offsets.first) << eth::Instruction::ADD << u256(offsets.second); + m_context << Instruction::DUP1 << u256(offsets.first) << Instruction::ADD << u256(offsets.second); TypePointer memberType = structType->memberType(names[i]); StorageItem(m_context, *memberType).retrieveValue(SourceLocation(), true); utils().convertType(*memberType, *returnTypes[i]); @@ -160,7 +160,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& retSizeOnStack += returnTypes[i]->sizeOnStack(); } // remove slot - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else { @@ -172,7 +172,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& } solAssert(retSizeOnStack == utils().sizeOnStack(returnTypes), ""); solAssert(retSizeOnStack <= 15, "Stack is too deep."); - m_context << eth::dupInstruction(retSizeOnStack + 1); + m_context << dupInstruction(retSizeOnStack + 1); m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction); } @@ -226,7 +226,7 @@ bool ExpressionCompiler::visit(Assignment const& _assignment) solAssert(itemSize + lvalueSize <= 16, "Stack too deep, try removing local variables."); // value [lvalue_ref] updated_value for (unsigned i = 0; i < itemSize; ++i) - m_context << eth::swapInstruction(itemSize + lvalueSize) << eth::Instruction::POP; + m_context << swapInstruction(itemSize + lvalueSize) << Instruction::POP; } } m_currentLValue->storeValue(*type, _assignment.location()); @@ -243,7 +243,7 @@ bool ExpressionCompiler::visit(TupleExpression const& _tuple) solAssert(!arrayType.isDynamicallySized(), "Cannot create dynamically sized inline array."); m_context << max(u256(32u), arrayType.memorySize()); utils().allocateMemory(); - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; for (auto const& component: _tuple.components()) { @@ -252,7 +252,7 @@ bool ExpressionCompiler::visit(TupleExpression const& _tuple) utils().storeInMemoryDynamic(*arrayType.baseType(), true); } - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else { @@ -298,13 +298,13 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation) switch (_unaryOperation.getOperator()) { case Token::Not: // ! - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; break; case Token::BitNot: // ~ - m_context << eth::Instruction::NOT; + m_context << Instruction::NOT; break; case Token::After: // after - m_context << eth::Instruction::TIMESTAMP << eth::Instruction::ADD; + m_context << Instruction::TIMESTAMP << Instruction::ADD; break; case Token::Delete: // delete solAssert(!!m_currentLValue, "LValue not retrieved."); @@ -319,20 +319,20 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation) { // store value for later solAssert(_unaryOperation.annotation().type->sizeOnStack() == 1, "Stack size != 1 not implemented."); - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; if (m_currentLValue->sizeOnStack() > 0) for (unsigned i = 1 + m_currentLValue->sizeOnStack(); i > 0; --i) - m_context << eth::swapInstruction(i); + m_context << swapInstruction(i); } m_context << u256(1); if (_unaryOperation.getOperator() == Token::Inc) - m_context << eth::Instruction::ADD; + m_context << Instruction::ADD; else - m_context << eth::Instruction::SWAP1 << eth::Instruction::SUB; + m_context << Instruction::SWAP1 << Instruction::SUB; // Stack for prefix: [ref...] (*ref)+-1 // Stack for postfix: *ref [ref...] (*ref)+-1 for (unsigned i = m_currentLValue->sizeOnStack(); i > 0; --i) - m_context << eth::swapInstruction(i); + m_context << swapInstruction(i); m_currentLValue->storeValue( *_unaryOperation.annotation().type, _unaryOperation.location(), !_unaryOperation.isPrefixOperation()); @@ -342,7 +342,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation) // unary add, so basically no-op break; case Token::Sub: // - - m_context << u256(0) << eth::Instruction::SUB; + m_context << u256(0) << Instruction::SUB; break; default: BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid unary operator: " + @@ -452,7 +452,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) m_context << max(u256(32u), structType.memorySize()); utils().allocateMemory(); - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; for (unsigned i = 0; i < arguments.size(); ++i) { @@ -460,7 +460,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) utils().convertType(*arguments[i]->annotation().type, *functionType->parameterTypes()[i]); utils().storeInMemoryDynamic(*functionType->parameterTypes()[i]); } - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else { @@ -518,21 +518,21 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) utils().fetchFreeMemoryPointer(); // pushes size eth::AssemblyItem subroutine = m_context.addSubroutine(assembly); - m_context << eth::Instruction::DUP1 << subroutine; - m_context << eth::Instruction::DUP4 << eth::Instruction::CODECOPY; + m_context << Instruction::DUP1 << subroutine; + m_context << Instruction::DUP4 << Instruction::CODECOPY; - m_context << eth::Instruction::ADD; + m_context << Instruction::ADD; utils().encodeToMemory(argumentTypes, function.parameterTypes()); // now on stack: memory_end_ptr // need: size, offset, endowment utils().toSizeAfterFreeMemoryPointer(); if (function.valueSet()) - m_context << eth::dupInstruction(3); + m_context << dupInstruction(3); else m_context << u256(0); - m_context << eth::Instruction::CREATE; + m_context << Instruction::CREATE; if (function.valueSet()) - m_context << eth::swapInstruction(1) << eth::Instruction::POP; + m_context << swapInstruction(1) << Instruction::POP; break; } case Location::SetGas: @@ -546,9 +546,9 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) // Its values of gasSet and valueSet is equal to the original function's though. unsigned stackDepth = (function.gasSet() ? 1 : 0) + (function.valueSet() ? 1 : 0); if (stackDepth > 0) - m_context << eth::swapInstruction(stackDepth); + m_context << swapInstruction(stackDepth); if (function.gasSet()) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; break; } case Location::SetValue: @@ -557,7 +557,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) // Note that function is not the original function, but the ".value" function. // Its values of gasSet and valueSet is equal to the original function's though. if (function.valueSet()) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; arguments.front()->accept(*this); break; case Location::Send: @@ -586,7 +586,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) case Location::Selfdestruct: arguments.front()->accept(*this); utils().convertType(*arguments.front()->annotation().type, *function.parameterTypes().front(), true); - m_context << eth::Instruction::SUICIDE; + m_context << Instruction::SUICIDE; break; case Location::SHA3: { @@ -599,7 +599,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) utils().fetchFreeMemoryPointer(); utils().encodeToMemory(argumentTypes, TypePointers(), function.padArguments(), true); utils().toSizeAfterFreeMemoryPointer(); - m_context << eth::Instruction::SHA3; + m_context << Instruction::SHA3; break; } case Location::Log0: @@ -622,7 +622,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) false, true); utils().toSizeAfterFreeMemoryPointer(); - m_context << eth::logInstruction(logNumber); + m_context << logInstruction(logNumber); break; } case Location::Event: @@ -646,7 +646,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) true ); utils().toSizeAfterFreeMemoryPointer(); - m_context << eth::Instruction::SHA3; + m_context << Instruction::SHA3; } else utils().convertType( @@ -676,14 +676,14 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) utils().encodeToMemory(nonIndexedArgTypes, nonIndexedParamTypes); // need: topic1 ... topicn memsize memstart utils().toSizeAfterFreeMemoryPointer(); - m_context << eth::logInstruction(numIndexed); + m_context << logInstruction(numIndexed); break; } case Location::BlockHash: { arguments[0]->accept(*this); utils().convertType(*arguments[0]->annotation().type, *function.parameterTypes()[0], true); - m_context << eth::Instruction::BLOCKHASH; + m_context << Instruction::BLOCKHASH; break; } case Location::AddMod: @@ -695,9 +695,9 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) utils().convertType(*arguments[2 - i]->annotation().type, IntegerType(256)); } if (function.location() == Location::AddMod) - m_context << eth::Instruction::ADDMOD; + m_context << Instruction::ADDMOD; else - m_context << eth::Instruction::MULMOD; + m_context << Instruction::MULMOD; break; } case Location::ECRecover: @@ -710,7 +710,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) {Location::RIPEMD160, 3}}; m_context << contractAddresses.find(function.location())->second; for (unsigned i = function.sizeOnStack(); i > 0; --i) - m_context << eth::swapInstruction(i); + m_context << swapInstruction(i); appendExternalFunctionCall(function, arguments); break; } @@ -727,13 +727,13 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) make_shared<ArrayType>(DataLocation::Storage); // get the current length ArrayUtils(m_context).retrieveLength(*arrayType); - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; // stack: ArrayReference currentLength currentLength - m_context << u256(1) << eth::Instruction::ADD; + m_context << u256(1) << Instruction::ADD; // stack: ArrayReference currentLength newLength - m_context << eth::Instruction::DUP3 << eth::Instruction::DUP2; + m_context << Instruction::DUP3 << Instruction::DUP2; ArrayUtils(m_context).resizeDynamicArray(*arrayType); - m_context << eth::Instruction::SWAP2 << eth::Instruction::SWAP1; + m_context << Instruction::SWAP2 << Instruction::SWAP1; // stack: newLength ArrayReference oldLength ArrayUtils(m_context).accessIndex(*arrayType, false); @@ -766,36 +766,36 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall) // Stack: requested_length // Allocate at max(MSIZE, freeMemoryPointer) utils().fetchFreeMemoryPointer(); - m_context << eth::Instruction::DUP1 << eth::Instruction::MSIZE; - m_context << eth::Instruction::LT; + m_context << Instruction::DUP1 << Instruction::MSIZE; + m_context << Instruction::LT; auto initialise = m_context.appendConditionalJump(); // Free memory pointer does not point to empty memory, use MSIZE. - m_context << eth::Instruction::POP; - m_context << eth::Instruction::MSIZE; + m_context << Instruction::POP; + m_context << Instruction::MSIZE; m_context << initialise; // Stack: requested_length memptr - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; // Stack: memptr requested_length // store length - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP3 << eth::Instruction::MSTORE; + m_context << Instruction::DUP1 << Instruction::DUP3 << Instruction::MSTORE; // Stack: memptr requested_length // update free memory pointer - m_context << eth::Instruction::DUP1 << arrayType.baseType()->memoryHeadSize(); - m_context << eth::Instruction::MUL << u256(32) << eth::Instruction::ADD; - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << Instruction::DUP1 << arrayType.baseType()->memoryHeadSize(); + m_context << Instruction::MUL << u256(32) << Instruction::ADD; + m_context << Instruction::DUP3 << Instruction::ADD; utils().storeFreeMemoryPointer(); // Stack: memptr requested_length // We only have to initialise if the base type is a not a value type. if (dynamic_cast<ReferenceType const*>(arrayType.baseType().get())) { - m_context << eth::Instruction::DUP2 << u256(32) << eth::Instruction::ADD; + m_context << Instruction::DUP2 << u256(32) << Instruction::ADD; utils().zeroInitialiseMemoryArray(arrayType); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else - m_context << eth::Instruction::POP; + m_context << Instruction::POP; break; } default: @@ -876,7 +876,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess) IntegerType(0, IntegerType::Modifier::Address), true ); - m_context << eth::Instruction::BALANCE; + m_context << Instruction::BALANCE; } else if ((set<string>{"send", "call", "callcode", "delegatecall"}).count(member)) utils().convertType( @@ -894,30 +894,30 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess) case Type::Category::Magic: // we can ignore the kind of magic and only look at the name of the member if (member == "coinbase") - m_context << eth::Instruction::COINBASE; + m_context << Instruction::COINBASE; else if (member == "timestamp") - m_context << eth::Instruction::TIMESTAMP; + m_context << Instruction::TIMESTAMP; else if (member == "difficulty") - m_context << eth::Instruction::DIFFICULTY; + m_context << Instruction::DIFFICULTY; else if (member == "number") - m_context << eth::Instruction::NUMBER; + m_context << Instruction::NUMBER; else if (member == "gaslimit") - m_context << eth::Instruction::GASLIMIT; + m_context << Instruction::GASLIMIT; else if (member == "sender") - m_context << eth::Instruction::CALLER; + m_context << Instruction::CALLER; else if (member == "value") - m_context << eth::Instruction::CALLVALUE; + m_context << Instruction::CALLVALUE; else if (member == "origin") - m_context << eth::Instruction::ORIGIN; + m_context << Instruction::ORIGIN; else if (member == "gas") - m_context << eth::Instruction::GAS; + m_context << Instruction::GAS; else if (member == "gasprice") - m_context << eth::Instruction::GASPRICE; + m_context << Instruction::GASPRICE; else if (member == "data") - m_context << u256(0) << eth::Instruction::CALLDATASIZE; + m_context << u256(0) << Instruction::CALLDATASIZE; else if (member == "sig") - m_context << u256(0) << eth::Instruction::CALLDATALOAD - << (u256(0xffffffff) << (256 - 32)) << eth::Instruction::AND; + m_context << u256(0) << Instruction::CALLDATALOAD + << (u256(0xffffffff) << (256 - 32)) << Instruction::AND; else BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown magic member.")); break; @@ -929,13 +929,13 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess) case DataLocation::Storage: { pair<u256, unsigned> const& offsets = type.storageOffsetsOfMember(member); - m_context << offsets.first << eth::Instruction::ADD << u256(offsets.second); + m_context << offsets.first << Instruction::ADD << u256(offsets.second); setLValueToStorageItem(_memberAccess); break; } case DataLocation::Memory: { - m_context << type.memoryOffsetOfMember(member) << eth::Instruction::ADD; + m_context << type.memoryOffsetOfMember(member) << Instruction::ADD; setLValue<MemoryItem>(_memberAccess, *_memberAccess.annotation().type); break; } @@ -986,13 +986,13 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess) switch (type.location()) { case DataLocation::CallData: - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; break; case DataLocation::Storage: setLValue<StorageArrayLength>(_memberAccess, type); break; case DataLocation::Memory: - m_context << eth::Instruction::MLOAD; + m_context << Instruction::MLOAD; break; } } @@ -1046,7 +1046,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess) false, true ); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; utils().storeInMemoryDynamic(IntegerType(256)); utils().toSizeAfterFreeMemoryPointer(); } @@ -1054,12 +1054,12 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess) { m_context << u256(0); // memory position appendExpressionCopyToMemory(*keyType, *_indexAccess.indexExpression()); - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; solAssert(CompilerUtils::freeMemoryPointer >= 0x40, ""); utils().storeInMemoryDynamic(IntegerType(256)); m_context << u256(0); } - m_context << eth::Instruction::SHA3; + m_context << Instruction::SHA3; m_context << u256(0); setLValueToStorageItem(_indexAccess); } @@ -1109,12 +1109,12 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess) // stack layout: <value> <index> // check out-of-bounds access m_context << u256(fixedBytesType.numBytes()); - m_context << eth::Instruction::DUP2 << eth::Instruction::LT << eth::Instruction::ISZERO; + m_context << Instruction::DUP2 << Instruction::LT << Instruction::ISZERO; // out-of-bounds access throws exception m_context.appendConditionalJumpTo(m_context.errorTag()); - m_context << eth::Instruction::BYTE; - m_context << (u256(1) << (256 - 8)) << eth::Instruction::MUL; + m_context << Instruction::BYTE; + m_context << (u256(1) << (256 - 8)) << Instruction::MUL; } else if (baseType.category() == Type::Category::TypeType) { @@ -1139,11 +1139,11 @@ void ExpressionCompiler::endVisit(Identifier const& _identifier) case Type::Category::Contract: // "this" or "super" if (!dynamic_cast<ContractType const&>(*magicVar->type()).isSuper()) - m_context << eth::Instruction::ADDRESS; + m_context << Instruction::ADDRESS; break; case Type::Category::Integer: // "now" - m_context << eth::Instruction::TIMESTAMP; + m_context << Instruction::TIMESTAMP; break; default: break; @@ -1208,11 +1208,11 @@ void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryO solAssert(c_op == Token::Or || c_op == Token::And, ""); _binaryOperation.leftExpression().accept(*this); - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; if (c_op == Token::And) - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; eth::AssemblyItem endLabel = m_context.appendConditionalJump(); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; _binaryOperation.rightExpression().accept(*this); m_context << endLabel; } @@ -1221,9 +1221,9 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type { if (_operator == Token::Equal || _operator == Token::NotEqual) { - m_context << eth::Instruction::EQ; + m_context << Instruction::EQ; if (_operator == Token::NotEqual) - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; } else { @@ -1235,19 +1235,19 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type { case Token::GreaterThanOrEqual: m_context << - (isSigned ? eth::Instruction::SLT : eth::Instruction::LT) << - eth::Instruction::ISZERO; + (isSigned ? Instruction::SLT : Instruction::LT) << + Instruction::ISZERO; break; case Token::LessThanOrEqual: m_context << - (isSigned ? eth::Instruction::SGT : eth::Instruction::GT) << - eth::Instruction::ISZERO; + (isSigned ? Instruction::SGT : Instruction::GT) << + Instruction::ISZERO; break; case Token::GreaterThan: - m_context << (isSigned ? eth::Instruction::SGT : eth::Instruction::GT); + m_context << (isSigned ? Instruction::SGT : Instruction::GT); break; case Token::LessThan: - m_context << (isSigned ? eth::Instruction::SLT : eth::Instruction::LT); + m_context << (isSigned ? Instruction::SLT : Instruction::LT); break; default: BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown comparison operator.")); @@ -1275,22 +1275,22 @@ void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Ty switch (_operator) { case Token::Add: - m_context << eth::Instruction::ADD; + m_context << Instruction::ADD; break; case Token::Sub: - m_context << eth::Instruction::SUB; + m_context << Instruction::SUB; break; case Token::Mul: - m_context << eth::Instruction::MUL; + m_context << Instruction::MUL; break; case Token::Div: - m_context << (c_isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV); + m_context << (c_isSigned ? Instruction::SDIV : Instruction::DIV); break; case Token::Mod: - m_context << (c_isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD); + m_context << (c_isSigned ? Instruction::SMOD : Instruction::MOD); break; case Token::Exp: - m_context << eth::Instruction::EXP; + m_context << Instruction::EXP; break; default: BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown arithmetic operator.")); @@ -1302,13 +1302,13 @@ void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator) switch (_operator) { case Token::BitOr: - m_context << eth::Instruction::OR; + m_context << Instruction::OR; break; case Token::BitAnd: - m_context << eth::Instruction::AND; + m_context << Instruction::AND; break; case Token::BitXor: - m_context << eth::Instruction::XOR; + m_context << Instruction::XOR; break; default: BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown bit operator.")); @@ -1392,7 +1392,7 @@ void ExpressionCompiler::appendExternalFunctionCall( true ); for (unsigned i = 0; i < gasValueSize; ++i) - m_context << eth::swapInstruction(gasValueSize - i); + m_context << swapInstruction(gasValueSize - i); gasStackPos++; valueStackPos++; } @@ -1411,7 +1411,7 @@ void ExpressionCompiler::appendExternalFunctionCall( utils().fetchFreeMemoryPointer(); if (!_functionType.isBareCall() || manualFunctionId) { - m_context << eth::dupInstruction(2 + gasValueSize + CompilerUtils::sizeOnStack(argumentTypes)); + m_context << dupInstruction(2 + gasValueSize + CompilerUtils::sizeOnStack(argumentTypes)); utils().storeInMemoryDynamic(IntegerType(8 * CompilerUtils::dataStartOffset), false); } // If the function takes arbitrary parameters, copy dynamic length data in place. @@ -1437,21 +1437,21 @@ void ExpressionCompiler::appendExternalFunctionCall( // put on stack: <size of output> <memory pos of output> <size of input> <memory pos of input> m_context << u256(retSize); utils().fetchFreeMemoryPointer(); - m_context << eth::Instruction::DUP1 << eth::Instruction::DUP4 << eth::Instruction::SUB; - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP1 << Instruction::DUP4 << Instruction::SUB; + m_context << Instruction::DUP2; // CALL arguments: outSize, outOff, inSize, inOff (already present up to here) // [value,] addr, gas (stack top) if (isDelegateCall) solAssert(!_functionType.valueSet(), "Value set for delegatecall"); else if (_functionType.valueSet()) - m_context << eth::dupInstruction(m_context.baseToCurrentStackOffset(valueStackPos)); + m_context << dupInstruction(m_context.baseToCurrentStackOffset(valueStackPos)); else m_context << u256(0); - m_context << eth::dupInstruction(m_context.baseToCurrentStackOffset(contractStackPos)); + m_context << dupInstruction(m_context.baseToCurrentStackOffset(contractStackPos)); if (_functionType.gasSet()) - m_context << eth::dupInstruction(m_context.baseToCurrentStackOffset(gasStackPos)); + m_context << dupInstruction(m_context.baseToCurrentStackOffset(gasStackPos)); else { eth::EVMSchedule schedule; @@ -1464,15 +1464,15 @@ void ExpressionCompiler::appendExternalFunctionCall( gasNeededByCaller += schedule.callNewAccountGas; // we never know m_context << gasNeededByCaller << - eth::Instruction::GAS << - eth::Instruction::SUB; + Instruction::GAS << + Instruction::SUB; } if (isDelegateCall) - m_context << eth::Instruction::DELEGATECALL; + m_context << Instruction::DELEGATECALL; else if (isCallCode) - m_context << eth::Instruction::CALLCODE; + m_context << Instruction::CALLCODE; else - m_context << eth::Instruction::CALL; + m_context << Instruction::CALL; unsigned remainsSize = 2 + // contract address, input_memory_end @@ -1481,11 +1481,11 @@ void ExpressionCompiler::appendExternalFunctionCall( (!_functionType.isBareCall() || manualFunctionId); if (returnSuccessCondition) - m_context << eth::swapInstruction(remainsSize); + m_context << swapInstruction(remainsSize); else { //Propagate error condition (if CALL pushes 0 on stack). - m_context << eth::Instruction::ISZERO; + m_context << Instruction::ISZERO; m_context.appendConditionalJumpTo(m_context.errorTag()); } @@ -1515,7 +1515,7 @@ void ExpressionCompiler::appendExternalFunctionCall( if (memoryNeeded) utils().storeFreeMemoryPointer(); else - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } } diff --git a/libsolidity/codegen/LValue.cpp b/libsolidity/codegen/LValue.cpp index fdef6937..fcadd2ff 100644 --- a/libsolidity/codegen/LValue.cpp +++ b/libsolidity/codegen/LValue.cpp @@ -21,7 +21,7 @@ */ #include <libsolidity/codegen/LValue.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libsolidity/ast/Types.h> #include <libsolidity/ast/AST.h> #include <libsolidity/codegen/CompilerUtils.h> @@ -49,7 +49,7 @@ void StackVariable::retrieveValue(SourceLocation const& _location, bool) const ); solAssert(stackPos + 1 >= m_size, "Size and stack pos mismatch."); for (unsigned i = 0; i < m_size; ++i) - m_context << eth::dupInstruction(stackPos + 1); + m_context << dupInstruction(stackPos + 1); } void StackVariable::storeValue(Type const&, SourceLocation const& _location, bool _move) const @@ -63,7 +63,7 @@ void StackVariable::storeValue(Type const&, SourceLocation const& _location, boo ); else if (stackDiff > 0) for (unsigned i = 0; i < m_size; ++i) - m_context << eth::swapInstruction(stackDiff) << eth::Instruction::POP; + m_context << swapInstruction(stackDiff) << Instruction::POP; if (!_move) retrieveValue(_location); } @@ -85,11 +85,11 @@ void MemoryItem::retrieveValue(SourceLocation const&, bool _remove) const if (m_dataType->isValueType()) { if (!_remove) - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; CompilerUtils(m_context).loadFromMemoryDynamic(*m_dataType, false, m_padded, false); } else - m_context << eth::Instruction::MLOAD; + m_context << Instruction::MLOAD; } void MemoryItem::storeValue(Type const& _sourceType, SourceLocation const&, bool _move) const @@ -109,13 +109,13 @@ void MemoryItem::storeValue(Type const& _sourceType, SourceLocation const&, bool { solAssert(m_dataType->calldataEncodedSize(false) == 1, "Invalid non-padded type."); if (m_dataType->category() == Type::Category::FixedBytes) - m_context << u256(0) << eth::Instruction::BYTE; - m_context << eth::Instruction::SWAP1 << eth::Instruction::MSTORE8; + m_context << u256(0) << Instruction::BYTE; + m_context << Instruction::SWAP1 << Instruction::MSTORE8; } else { utils.storeInMemoryDynamic(*m_dataType, m_padded); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } } else @@ -124,10 +124,10 @@ void MemoryItem::storeValue(Type const& _sourceType, SourceLocation const&, bool solAssert(m_dataType->sizeOnStack() == 1, ""); if (!_move) - m_context << eth::Instruction::DUP2 << eth::Instruction::SWAP1; + m_context << Instruction::DUP2 << Instruction::SWAP1; // stack: [value] value lvalue // only store the reference - m_context << eth::Instruction::MSTORE; + m_context << Instruction::MSTORE; } } @@ -135,10 +135,10 @@ void MemoryItem::setToZero(SourceLocation const&, bool _removeReference) const { CompilerUtils utils(m_context); if (!_removeReference) - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; utils.pushZeroValue(*m_dataType); utils.storeInMemoryDynamic(*m_dataType, m_padded); - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } StorageItem::StorageItem(CompilerContext& _compilerContext, VariableDeclaration const& _declaration): @@ -165,29 +165,29 @@ void StorageItem::retrieveValue(SourceLocation const&, bool _remove) const { solAssert(m_dataType->sizeOnStack() == 1, "Invalid storage ref size."); if (_remove) - m_context << eth::Instruction::POP; // remove byte offset + m_context << Instruction::POP; // remove byte offset else - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP2; return; } if (!_remove) CompilerUtils(m_context).copyToStackTop(sizeOnStack(), sizeOnStack()); if (m_dataType->storageBytes() == 32) - m_context << eth::Instruction::POP << eth::Instruction::SLOAD; + m_context << Instruction::POP << Instruction::SLOAD; else { m_context - << eth::Instruction::SWAP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP1 - << u256(0x100) << eth::Instruction::EXP << eth::Instruction::SWAP1 << eth::Instruction::DIV; + << Instruction::SWAP1 << Instruction::SLOAD << Instruction::SWAP1 + << u256(0x100) << Instruction::EXP << Instruction::SWAP1 << Instruction::DIV; if (m_dataType->category() == Type::Category::FixedBytes) - m_context << (u256(0x1) << (256 - 8 * m_dataType->storageBytes())) << eth::Instruction::MUL; + m_context << (u256(0x1) << (256 - 8 * m_dataType->storageBytes())) << Instruction::MUL; else if ( m_dataType->category() == Type::Category::Integer && dynamic_cast<IntegerType const&>(*m_dataType).isSigned() ) - m_context << u256(m_dataType->storageBytes() - 1) << eth::Instruction::SIGNEXTEND; + m_context << u256(m_dataType->storageBytes() - 1) << Instruction::SIGNEXTEND; else - m_context << ((u256(0x1) << (8 * m_dataType->storageBytes())) - 1) << eth::Instruction::AND; + m_context << ((u256(0x1) << (8 * m_dataType->storageBytes())) - 1) << Instruction::AND; } } @@ -202,32 +202,32 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc if (m_dataType->storageBytes() == 32) { // offset should be zero - m_context << eth::Instruction::POP; + m_context << Instruction::POP; if (!_move) - m_context << eth::Instruction::DUP2 << eth::Instruction::SWAP1; - m_context << eth::Instruction::SSTORE; + m_context << Instruction::DUP2 << Instruction::SWAP1; + m_context << Instruction::SSTORE; } else { // OR the value into the other values in the storage slot - m_context << u256(0x100) << eth::Instruction::EXP; + m_context << u256(0x100) << Instruction::EXP; // stack: value storage_ref multiplier // fetch old value - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD; + m_context << Instruction::DUP2 << Instruction::SLOAD; // stack: value storege_ref multiplier old_full_value // clear bytes in old value m_context - << eth::Instruction::DUP2 << ((u256(1) << (8 * m_dataType->storageBytes())) - 1) - << eth::Instruction::MUL; - m_context << eth::Instruction::NOT << eth::Instruction::AND; + << Instruction::DUP2 << ((u256(1) << (8 * m_dataType->storageBytes())) - 1) + << Instruction::MUL; + m_context << Instruction::NOT << Instruction::AND; // stack: value storage_ref multiplier cleared_value m_context - << eth::Instruction::SWAP1 << eth::Instruction::DUP4; + << Instruction::SWAP1 << Instruction::DUP4; // stack: value storage_ref cleared_value multiplier value if (m_dataType->category() == Type::Category::FixedBytes) m_context << (u256(0x1) << (256 - 8 * dynamic_cast<FixedBytesType const&>(*m_dataType).numBytes())) - << eth::Instruction::SWAP1 << eth::Instruction::DIV; + << Instruction::SWAP1 << Instruction::DIV; else if ( m_dataType->category() == Type::Category::Integer && dynamic_cast<IntegerType const&>(*m_dataType).isSigned() @@ -235,15 +235,15 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc // remove the higher order bits m_context << (u256(1) << (8 * (32 - m_dataType->storageBytes()))) - << eth::Instruction::SWAP1 - << eth::Instruction::DUP2 - << eth::Instruction::MUL - << eth::Instruction::DIV; - m_context << eth::Instruction::MUL << eth::Instruction::OR; + << Instruction::SWAP1 + << Instruction::DUP2 + << Instruction::MUL + << Instruction::DIV; + m_context << Instruction::MUL << Instruction::OR; // stack: value storage_ref updated_value - m_context << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + m_context << Instruction::SWAP1 << Instruction::SSTORE; if (_move) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } } else @@ -253,19 +253,19 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc "Wrong type conversation for assignment."); if (m_dataType->category() == Type::Category::Array) { - m_context << eth::Instruction::POP; // remove byte offset + m_context << Instruction::POP; // remove byte offset ArrayUtils(m_context).copyArrayToStorage( dynamic_cast<ArrayType const&>(*m_dataType), dynamic_cast<ArrayType const&>(_sourceType) ); if (_move) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } else if (m_dataType->category() == Type::Category::Struct) { // stack layout: source_ref target_ref target_offset // note that we have structs, so offset should be zero and are ignored - m_context << eth::Instruction::POP; + m_context << Instruction::POP; auto const& structType = dynamic_cast<StructType const&>(*m_dataType); auto const& sourceType = dynamic_cast<StructType const&>(_sourceType); solAssert( @@ -284,7 +284,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc { // stack layout: source_ref target_ref pair<u256, unsigned> const& offsets = sourceType.storageOffsetsOfMember(member.name); - m_context << offsets.first << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << offsets.first << Instruction::DUP3 << Instruction::ADD; m_context << u256(offsets.second); // stack: source_ref target_ref source_member_ref source_member_off StorageItem(m_context, *sourceMemberType).retrieveValue(_location, true); @@ -296,13 +296,13 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc // stack layout: source_ref target_ref TypePointer sourceMemberType = sourceType.memberType(member.name); m_context << sourceType.memoryOffsetOfMember(member.name); - m_context << eth::Instruction::DUP3 << eth::Instruction::ADD; + m_context << Instruction::DUP3 << Instruction::ADD; MemoryItem(m_context, *sourceMemberType).retrieveValue(_location, true); // stack layout: source_ref target_ref source_value... } unsigned stackSize = sourceMemberType->sizeOnStack(); pair<u256, unsigned> const& offsets = structType.storageOffsetsOfMember(member.name); - m_context << eth::dupInstruction(1 + stackSize) << offsets.first << eth::Instruction::ADD; + m_context << dupInstruction(1 + stackSize) << offsets.first << Instruction::ADD; m_context << u256(offsets.second); // stack: source_ref target_ref target_off source_value... target_member_ref target_member_byte_off StorageItem(m_context, *memberType).storeValue(*sourceMemberType, _location, true); @@ -312,7 +312,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc if (_move) utils.popStackSlots(2); else - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; } else BOOST_THROW_EXCEPTION( @@ -344,12 +344,12 @@ void StorageItem::setToZero(SourceLocation const&, bool _removeReference) const continue; pair<u256, unsigned> const& offsets = structType.storageOffsetsOfMember(member.name); m_context - << offsets.first << eth::Instruction::DUP3 << eth::Instruction::ADD + << offsets.first << Instruction::DUP3 << Instruction::ADD << u256(offsets.second); StorageItem(m_context, *memberType).setToZero(); } if (_removeReference) - m_context << eth::Instruction::POP << eth::Instruction::POP; + m_context << Instruction::POP << Instruction::POP; } else { @@ -360,23 +360,23 @@ void StorageItem::setToZero(SourceLocation const&, bool _removeReference) const { // offset should be zero m_context - << eth::Instruction::POP << u256(0) - << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + << Instruction::POP << u256(0) + << Instruction::SWAP1 << Instruction::SSTORE; } else { - m_context << u256(0x100) << eth::Instruction::EXP; + m_context << u256(0x100) << Instruction::EXP; // stack: storage_ref multiplier // fetch old value - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD; + m_context << Instruction::DUP2 << Instruction::SLOAD; // stack: storege_ref multiplier old_full_value // clear bytes in old value m_context - << eth::Instruction::SWAP1 << ((u256(1) << (8 * m_dataType->storageBytes())) - 1) - << eth::Instruction::MUL; - m_context << eth::Instruction::NOT << eth::Instruction::AND; + << Instruction::SWAP1 << ((u256(1) << (8 * m_dataType->storageBytes())) - 1) + << Instruction::MUL; + m_context << Instruction::NOT << Instruction::AND; // stack: storage_ref cleared_value - m_context << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + m_context << Instruction::SWAP1 << Instruction::SSTORE; } } } @@ -393,48 +393,48 @@ void StorageByteArrayElement::retrieveValue(SourceLocation const&, bool _remove) { // stack: ref byte_number if (_remove) - m_context << eth::Instruction::SWAP1 << eth::Instruction::SLOAD - << eth::Instruction::SWAP1 << eth::Instruction::BYTE; + m_context << Instruction::SWAP1 << Instruction::SLOAD + << Instruction::SWAP1 << Instruction::BYTE; else - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD - << eth::Instruction::DUP2 << eth::Instruction::BYTE; - m_context << (u256(1) << (256 - 8)) << eth::Instruction::MUL; + m_context << Instruction::DUP2 << Instruction::SLOAD + << Instruction::DUP2 << Instruction::BYTE; + m_context << (u256(1) << (256 - 8)) << Instruction::MUL; } void StorageByteArrayElement::storeValue(Type const&, SourceLocation const&, bool _move) const { // stack: value ref byte_number - m_context << u256(31) << eth::Instruction::SUB << u256(0x100) << eth::Instruction::EXP; + m_context << u256(31) << Instruction::SUB << u256(0x100) << Instruction::EXP; // stack: value ref (1<<(8*(31-byte_number))) - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD; + m_context << Instruction::DUP2 << Instruction::SLOAD; // stack: value ref (1<<(8*(31-byte_number))) old_full_value // clear byte in old value - m_context << eth::Instruction::DUP2 << u256(0xff) << eth::Instruction::MUL - << eth::Instruction::NOT << eth::Instruction::AND; + m_context << Instruction::DUP2 << u256(0xff) << Instruction::MUL + << Instruction::NOT << Instruction::AND; // stack: value ref (1<<(32-byte_number)) old_full_value_with_cleared_byte - m_context << eth::Instruction::SWAP1; - m_context << (u256(1) << (256 - 8)) << eth::Instruction::DUP5 << eth::Instruction::DIV - << eth::Instruction::MUL << eth::Instruction::OR; + m_context << Instruction::SWAP1; + m_context << (u256(1) << (256 - 8)) << Instruction::DUP5 << Instruction::DIV + << Instruction::MUL << Instruction::OR; // stack: value ref new_full_value - m_context << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + m_context << Instruction::SWAP1 << Instruction::SSTORE; if (_move) - m_context << eth::Instruction::POP; + m_context << Instruction::POP; } void StorageByteArrayElement::setToZero(SourceLocation const&, bool _removeReference) const { // stack: ref byte_number if (!_removeReference) - m_context << eth::Instruction::DUP2 << eth::Instruction::DUP2; - m_context << u256(31) << eth::Instruction::SUB << u256(0x100) << eth::Instruction::EXP; + m_context << Instruction::DUP2 << Instruction::DUP2; + m_context << u256(31) << Instruction::SUB << u256(0x100) << Instruction::EXP; // stack: ref (1<<(8*(31-byte_number))) - m_context << eth::Instruction::DUP2 << eth::Instruction::SLOAD; + m_context << Instruction::DUP2 << Instruction::SLOAD; // stack: ref (1<<(8*(31-byte_number))) old_full_value // clear byte in old value - m_context << eth::Instruction::SWAP1 << u256(0xff) << eth::Instruction::MUL; - m_context << eth::Instruction::NOT << eth::Instruction::AND; + m_context << Instruction::SWAP1 << u256(0xff) << Instruction::MUL; + m_context << Instruction::NOT << Instruction::AND; // stack: ref old_full_value_with_cleared_byte - m_context << eth::Instruction::SWAP1 << eth::Instruction::SSTORE; + m_context << Instruction::SWAP1 << Instruction::SSTORE; } StorageArrayLength::StorageArrayLength(CompilerContext& _compilerContext, const ArrayType& _arrayType): @@ -448,22 +448,22 @@ void StorageArrayLength::retrieveValue(SourceLocation const&, bool _remove) cons { ArrayUtils(m_context).retrieveLength(m_arrayType); if (_remove) - m_context << eth::Instruction::SWAP1 << eth::Instruction::POP; + m_context << Instruction::SWAP1 << Instruction::POP; } void StorageArrayLength::storeValue(Type const&, SourceLocation const&, bool _move) const { if (_move) - m_context << eth::Instruction::SWAP1; + m_context << Instruction::SWAP1; else - m_context << eth::Instruction::DUP2; + m_context << Instruction::DUP2; ArrayUtils(m_context).resizeDynamicArray(m_arrayType); } void StorageArrayLength::setToZero(SourceLocation const&, bool _removeReference) const { if (!_removeReference) - m_context << eth::Instruction::DUP1; + m_context << Instruction::DUP1; ArrayUtils(m_context).clearDynamicArray(m_arrayType); } diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp index 89e95bc1..5fa04087 100644 --- a/libsolidity/inlineasm/AsmCodeGen.cpp +++ b/libsolidity/inlineasm/AsmCodeGen.cpp @@ -25,6 +25,7 @@ #include <functional> #include <libevmasm/Assembly.h> #include <libevmasm/SourceLocation.h> +#include <libevmasm/Instruction.h> #include <libsolidity/inlineasm/AsmParser.h> #include <libsolidity/inlineasm/AsmData.h> @@ -116,7 +117,7 @@ public: m_identifierAccess = [](assembly::Identifier const&, eth::Assembly&, CodeGenerator::IdentifierContext) { return false; }; } - void operator()(Instruction const& _instruction) + void operator()(dev::solidity::assembly::Instruction const& _instruction) { m_state.assembly.append(_instruction.instruction); } @@ -145,7 +146,7 @@ public: "Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")" ); else - m_state.assembly.append(eth::dupInstruction(heightDiff)); + m_state.assembly.append(solidity::dupInstruction(heightDiff)); return; } else if (eth::AssemblyItem const* label = m_state.findLabel(_identifier.name)) @@ -196,7 +197,7 @@ public: //@TODO check height before and after while (m_state.variables.size() > numVariables) { - m_state.assembly.append(eth::Instruction::POP); + m_state.assembly.append(solidity::Instruction::POP); m_state.variables.pop_back(); } } @@ -215,8 +216,8 @@ private: ); else { - m_state.assembly.append(eth::swapInstruction(heightDiff)); - m_state.assembly.append(eth::Instruction::POP); + m_state.assembly.append(solidity::swapInstruction(heightDiff)); + m_state.assembly.append(solidity::Instruction::POP); } return; } diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h index 0361a4c2..42f0ae31 100644 --- a/libsolidity/inlineasm/AsmData.h +++ b/libsolidity/inlineasm/AsmData.h @@ -23,7 +23,7 @@ #pragma once #include <boost/variant.hpp> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> namespace dev { @@ -35,7 +35,7 @@ namespace assembly /// What follows are the AST nodes for assembly. /// Direct EVM instruction (except PUSHi and JUMPDEST) -struct Instruction { eth::Instruction instruction; }; +struct Instruction { solidity::Instruction instruction; }; /// Literal number or string (up to 32 bytes) struct Literal { bool isNumber; std::string value; }; /// External / internal identifier or label reference diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp index 124a5d26..68050733 100644 --- a/libsolidity/inlineasm/AsmParser.cpp +++ b/libsolidity/inlineasm/AsmParser.cpp @@ -23,7 +23,6 @@ #include <libsolidity/inlineasm/AsmParser.h> #include <ctype.h> #include <algorithm> -#include <libevmcore/Instruction.h> #include <libsolidity/parsing/Scanner.h> using namespace std; @@ -121,17 +120,17 @@ assembly::Statement Parser::parseExpression() assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher) { // Allowed instructions, lowercase names. - static map<string, eth::Instruction> s_instructions; + static map<string, dev::solidity::Instruction> s_instructions; if (s_instructions.empty()) - for (auto const& instruction: eth::c_instructions) + for (auto const& instruction: solidity::c_instructions) { if ( - instruction.second == eth::Instruction::JUMPDEST || - (eth::Instruction::PUSH1 <= instruction.second && instruction.second <= eth::Instruction::PUSH32) + instruction.second == solidity::Instruction::JUMPDEST || + (solidity::Instruction::PUSH1 <= instruction.second && instruction.second <= solidity::Instruction::PUSH32) ) continue; string name = instruction.first; - if (instruction.second == eth::Instruction::SUICIDE) + if (instruction.second == solidity::Instruction::SUICIDE) name = "selfdestruct"; transform(name.begin(), name.end(), name.begin(), [](unsigned char _c) { return tolower(_c); }); s_instructions[name] = instruction.second; @@ -152,10 +151,10 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher) // first search the set of instructions. if (s_instructions.count(literal)) { - eth::Instruction const& instr = s_instructions[literal]; + dev::solidity::Instruction const& instr = s_instructions[literal]; if (_onlySinglePusher) { - eth::InstructionInfo info = eth::instructionInfo(instr); + InstructionInfo info = dev::solidity::instructionInfo(instr); if (info.ret != 1) fatalParserError("Instruction " + info.name + " not allowed in this context."); } @@ -200,11 +199,11 @@ FunctionalInstruction Parser::parseFunctionalInstruction(assembly::Statement con { if (_instruction.type() != typeid(Instruction)) fatalParserError("Assembly instruction required in front of \"(\")"); - eth::Instruction instr = boost::get<Instruction>(_instruction).instruction; - eth::InstructionInfo instrInfo = eth::instructionInfo(instr); - if (eth::Instruction::DUP1 <= instr && instr <= eth::Instruction::DUP16) + solidity::Instruction instr = boost::get<solidity::assembly::Instruction>(_instruction).instruction; + InstructionInfo instrInfo = instructionInfo(instr); + if (solidity::Instruction::DUP1 <= instr && instr <= solidity::Instruction::DUP16) fatalParserError("DUPi instructions not allowed for functional notation"); - if (eth::Instruction::SWAP1 <= instr && instr <= eth::Instruction::SWAP16) + if (solidity::Instruction::SWAP1 <= instr && instr <= solidity::Instruction::SWAP16) fatalParserError("SWAPi instructions not allowed for functional notation"); expectToken(Token::LParen); diff --git a/libsolidity/interface/GasEstimator.cpp b/libsolidity/interface/GasEstimator.cpp index d460ba76..99ed75bc 100644 --- a/libsolidity/interface/GasEstimator.cpp +++ b/libsolidity/interface/GasEstimator.cpp @@ -137,8 +137,8 @@ GasEstimator::GasConsumption GasEstimator::functionalEstimation( using Id = ExpressionClasses::Id; using Ids = vector<Id>; Id hashValue = classes.find(u256(FixedHash<4>::Arith(FixedHash<4>(dev::sha3(_signature))))); - Id calldata = classes.find(eth::Instruction::CALLDATALOAD, Ids{classes.find(u256(0))}); - classes.forceEqual(hashValue, eth::Instruction::DIV, Ids{ + Id calldata = classes.find(Instruction::CALLDATALOAD, Ids{classes.find(u256(0))}); + classes.forceEqual(hashValue, Instruction::DIV, Ids{ calldata, classes.find(u256(1) << (8 * 28)) }); @@ -165,7 +165,7 @@ GasEstimator::GasConsumption GasEstimator::functionalEstimation( AssemblyItem invalidTag(PushTag, u256(-0x10)); state->feedItem(invalidTag, true); if (parametersSize > 0) - state->feedItem(eth::swapInstruction(parametersSize)); + state->feedItem(swapInstruction(parametersSize)); return PathGasMeter(_items).estimateMax(_offset, state); } diff --git a/lllc/CMakeLists.txt b/lllc/CMakeLists.txt index 989b8cbf..a897e663 100644 --- a/lllc/CMakeLists.txt +++ b/lllc/CMakeLists.txt @@ -6,7 +6,7 @@ file(GLOB HEADERS "*.h") include_directories(BEFORE ..) add_executable(${EXECUTABLE} ${SRC_LIST} ${HEADERS}) -eth_use(${EXECUTABLE} REQUIRED Solidity::lll Dev::buildinfo) +eth_use(${EXECUTABLE} REQUIRED Solidity::lll Dev::buildinfo Solidity::evmasm) install( TARGETS ${EXECUTABLE} DESTINATION bin ) diff --git a/lllc/main.cpp b/lllc/main.cpp index 5f3078c2..2c3b6a64 100644 --- a/lllc/main.cpp +++ b/lllc/main.cpp @@ -25,10 +25,11 @@ #include <liblll/Compiler.h> #include <libdevcore/CommonIO.h> #include <libdevcore/CommonData.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include "ethereum/BuildInfo.h" using namespace std; using namespace dev; +using namespace dev::solidity; using namespace dev::eth; void help() diff --git a/solc/CommandLineInterface.cpp b/solc/CommandLineInterface.cpp index a302e024..d82a2442 100644 --- a/solc/CommandLineInterface.cpp +++ b/solc/CommandLineInterface.cpp @@ -34,7 +34,7 @@ #include <libdevcore/Common.h> #include <libdevcore/CommonData.h> #include <libdevcore/CommonIO.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libsolidity/interface/Version.h> #include <libsolidity/parsing/Scanner.h> #include <libsolidity/parsing/Parser.h> @@ -161,11 +161,11 @@ void CommandLineInterface::handleBinary(string const& _contract) void CommandLineInterface::handleOpcode(string const& _contract) { if (m_args.count("output-dir")) - createFile(_contract + ".opcode", eth::disassemble(m_compiler->object(_contract).bytecode)); + createFile(_contract + ".opcode", solidity::disassemble(m_compiler->object(_contract).bytecode)); else { cout << "Opcodes: " << endl; - cout << eth::disassemble(m_compiler->object(_contract).bytecode); + cout << solidity::disassemble(m_compiler->object(_contract).bytecode); cout << endl; } } @@ -674,7 +674,7 @@ void CommandLineInterface::handleCombinedJSON() if (requests.count("clone-bin")) contractData["clone-bin"] = m_compiler->cloneObject(contractName).toHex(); if (requests.count("opcodes")) - contractData["opcodes"] = eth::disassemble(m_compiler->object(contractName).bytecode); + contractData["opcodes"] = solidity::disassemble(m_compiler->object(contractName).bytecode); if (requests.count("asm")) { ostringstream unused; diff --git a/solc/jsonCompiler.cpp b/solc/jsonCompiler.cpp index c6b40fdc..1c20d695 100644 --- a/solc/jsonCompiler.cpp +++ b/solc/jsonCompiler.cpp @@ -27,7 +27,7 @@ #include <libdevcore/Common.h> #include <libdevcore/CommonData.h> #include <libdevcore/CommonIO.h> -#include <libevmcore/Instruction.h> +#include <libevmasm/Instruction.h> #include <libsolidity/parsing/Scanner.h> #include <libsolidity/parsing/Parser.h> #include <libsolidity/ast/ASTPrinter.h> @@ -206,7 +206,7 @@ string compile(StringMap const& _sources, bool _optimize, CStyleReadFileCallback contractData["interface"] = compiler.interface(contractName); contractData["bytecode"] = compiler.object(contractName).toHex(); contractData["runtimeBytecode"] = compiler.runtimeObject(contractName).toHex(); - contractData["opcodes"] = eth::disassemble(compiler.object(contractName).bytecode); + contractData["opcodes"] = solidity::disassemble(compiler.object(contractName).bytecode); contractData["functionHashes"] = functionHashes(compiler.contractDefinition(contractName)); contractData["gasEstimates"] = estimateGas(compiler, contractName); ostringstream unused; diff --git a/test/libsolidity/SolidityExpressionCompiler.cpp b/test/libsolidity/SolidityExpressionCompiler.cpp index 0e814e56..a201604b 100644 --- a/test/libsolidity/SolidityExpressionCompiler.cpp +++ b/test/libsolidity/SolidityExpressionCompiler.cpp @@ -174,7 +174,7 @@ BOOST_AUTO_TEST_CASE(literal_true) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH1), 0x1}); + bytes expectation({byte(Instruction::PUSH1), 0x1}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -185,7 +185,7 @@ BOOST_AUTO_TEST_CASE(literal_false) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH1), 0x0}); + bytes expectation({byte(Instruction::PUSH1), 0x0}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -196,7 +196,7 @@ BOOST_AUTO_TEST_CASE(int_literal) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90, + bytes expectation({byte(Instruction::PUSH10), 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -212,7 +212,7 @@ BOOST_AUTO_TEST_CASE(int_with_wei_ether_subdenomination) })"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH1), 0x1}); + bytes expectation({byte(Instruction::PUSH1), 0x1}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -227,7 +227,7 @@ BOOST_AUTO_TEST_CASE(int_with_szabo_ether_subdenomination) })"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH5), 0xe8, 0xd4, 0xa5, 0x10, 0x00}); + bytes expectation({byte(Instruction::PUSH5), 0xe8, 0xd4, 0xa5, 0x10, 0x00}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -242,7 +242,7 @@ BOOST_AUTO_TEST_CASE(int_with_finney_ether_subdenomination) })"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH7), 0x3, 0x8d, 0x7e, 0xa4, 0xc6, 0x80, 0x00}); + bytes expectation({byte(Instruction::PUSH7), 0x3, 0x8d, 0x7e, 0xa4, 0xc6, 0x80, 0x00}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -257,7 +257,7 @@ BOOST_AUTO_TEST_CASE(int_with_ether_ether_subdenomination) })"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH8), 0xd, 0xe0, 0xb6, 0xb3, 0xa7, 0x64, 0x00, 0x00}); + bytes expectation({byte(Instruction::PUSH8), 0xd, 0xe0, 0xb6, 0xb3, 0xa7, 0x64, 0x00, 0x00}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -268,12 +268,12 @@ BOOST_AUTO_TEST_CASE(comparison) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::PUSH2), 0x11, 0xaa, - byte(eth::Instruction::PUSH2), 0x10, 0xaa, - byte(eth::Instruction::LT), - byte(eth::Instruction::EQ), - byte(eth::Instruction::ISZERO)}); + bytes expectation({byte(Instruction::PUSH1), 0x1, + byte(Instruction::PUSH2), 0x11, 0xaa, + byte(Instruction::PUSH2), 0x10, 0xaa, + byte(Instruction::LT), + byte(Instruction::EQ), + byte(Instruction::ISZERO)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -284,22 +284,22 @@ BOOST_AUTO_TEST_CASE(short_circuiting) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation({byte(eth::Instruction::PUSH1), 0x12, // 8 + 10 - byte(eth::Instruction::PUSH1), 0x4, - byte(eth::Instruction::GT), - byte(eth::Instruction::ISZERO), // after this we have 4 <= 8 + 10 - byte(eth::Instruction::DUP1), - byte(eth::Instruction::PUSH1), 0x11, - byte(eth::Instruction::JUMPI), // short-circuit if it is true - byte(eth::Instruction::POP), - byte(eth::Instruction::PUSH1), 0x2, - byte(eth::Instruction::PUSH1), 0x9, - byte(eth::Instruction::EQ), - byte(eth::Instruction::ISZERO), // after this we have 9 != 2 - byte(eth::Instruction::JUMPDEST), - byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::EQ), - byte(eth::Instruction::ISZERO)}); + bytes expectation({byte(Instruction::PUSH1), 0x12, // 8 + 10 + byte(Instruction::PUSH1), 0x4, + byte(Instruction::GT), + byte(Instruction::ISZERO), // after this we have 4 <= 8 + 10 + byte(Instruction::DUP1), + byte(Instruction::PUSH1), 0x11, + byte(Instruction::JUMPI), // short-circuit if it is true + byte(Instruction::POP), + byte(Instruction::PUSH1), 0x2, + byte(Instruction::PUSH1), 0x9, + byte(Instruction::EQ), + byte(Instruction::ISZERO), // after this we have 9 != 2 + byte(Instruction::JUMPDEST), + byte(Instruction::PUSH1), 0x1, + byte(Instruction::EQ), + byte(Instruction::ISZERO)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -309,23 +309,23 @@ BOOST_AUTO_TEST_CASE(arithmetics) " function f(uint y) { var x = ((((((((y ^ 8) & 7) | 6) - 5) + 4) % 3) / 2) * 1); }" "}\n"; bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}, {"test", "f", "x"}}); - bytes expectation({byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::PUSH1), 0x2, - byte(eth::Instruction::PUSH1), 0x3, - byte(eth::Instruction::PUSH1), 0x4, - byte(eth::Instruction::PUSH1), 0x5, - byte(eth::Instruction::PUSH1), 0x6, - byte(eth::Instruction::PUSH1), 0x7, - byte(eth::Instruction::PUSH1), 0x8, - byte(eth::Instruction::DUP10), - byte(eth::Instruction::XOR), - byte(eth::Instruction::AND), - byte(eth::Instruction::OR), - byte(eth::Instruction::SUB), - byte(eth::Instruction::ADD), - byte(eth::Instruction::MOD), - byte(eth::Instruction::DIV), - byte(eth::Instruction::MUL)}); + bytes expectation({byte(Instruction::PUSH1), 0x1, + byte(Instruction::PUSH1), 0x2, + byte(Instruction::PUSH1), 0x3, + byte(Instruction::PUSH1), 0x4, + byte(Instruction::PUSH1), 0x5, + byte(Instruction::PUSH1), 0x6, + byte(Instruction::PUSH1), 0x7, + byte(Instruction::PUSH1), 0x8, + byte(Instruction::DUP10), + byte(Instruction::XOR), + byte(Instruction::AND), + byte(Instruction::OR), + byte(Instruction::SUB), + byte(Instruction::ADD), + byte(Instruction::MOD), + byte(Instruction::DIV), + byte(Instruction::MUL)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -336,13 +336,13 @@ BOOST_AUTO_TEST_CASE(unary_operators) "}\n"; bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "y"}, {"test", "f", "x"}}); - bytes expectation({byte(eth::Instruction::PUSH1), 0x2, - byte(eth::Instruction::DUP3), - byte(eth::Instruction::PUSH1), 0x0, - byte(eth::Instruction::SUB), - byte(eth::Instruction::NOT), - byte(eth::Instruction::EQ), - byte(eth::Instruction::ISZERO)}); + bytes expectation({byte(Instruction::PUSH1), 0x2, + byte(Instruction::DUP3), + byte(Instruction::PUSH1), 0x0, + byte(Instruction::SUB), + byte(Instruction::NOT), + byte(Instruction::EQ), + byte(Instruction::ISZERO)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -354,44 +354,44 @@ BOOST_AUTO_TEST_CASE(unary_inc_dec) bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "x"}}); // Stack: a, x - bytes expectation({byte(eth::Instruction::DUP2), - byte(eth::Instruction::DUP1), - byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::ADD), + bytes expectation({byte(Instruction::DUP2), + byte(Instruction::DUP1), + byte(Instruction::PUSH1), 0x1, + byte(Instruction::ADD), // Stack here: a x a (a+1) - byte(eth::Instruction::SWAP3), - byte(eth::Instruction::POP), // first ++ + byte(Instruction::SWAP3), + byte(Instruction::POP), // first ++ // Stack here: (a+1) x a - byte(eth::Instruction::DUP3), - byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::ADD), + byte(Instruction::DUP3), + byte(Instruction::PUSH1), 0x1, + byte(Instruction::ADD), // Stack here: (a+1) x a (a+2) - byte(eth::Instruction::SWAP3), - byte(eth::Instruction::POP), + byte(Instruction::SWAP3), + byte(Instruction::POP), // Stack here: (a+2) x a - byte(eth::Instruction::DUP3), // second ++ - byte(eth::Instruction::XOR), + byte(Instruction::DUP3), // second ++ + byte(Instruction::XOR), // Stack here: (a+2) x a^(a+2) - byte(eth::Instruction::DUP3), - byte(eth::Instruction::DUP1), - byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::SWAP1), - byte(eth::Instruction::SUB), + byte(Instruction::DUP3), + byte(Instruction::DUP1), + byte(Instruction::PUSH1), 0x1, + byte(Instruction::SWAP1), + byte(Instruction::SUB), // Stack here: (a+2) x a^(a+2) (a+2) (a+1) - byte(eth::Instruction::SWAP4), - byte(eth::Instruction::POP), // first -- - byte(eth::Instruction::XOR), + byte(Instruction::SWAP4), + byte(Instruction::POP), // first -- + byte(Instruction::XOR), // Stack here: (a+1) x a^(a+2)^(a+2) - byte(eth::Instruction::DUP3), - byte(eth::Instruction::PUSH1), 0x1, - byte(eth::Instruction::SWAP1), - byte(eth::Instruction::SUB), + byte(Instruction::DUP3), + byte(Instruction::PUSH1), 0x1, + byte(Instruction::SWAP1), + byte(Instruction::SUB), // Stack here: (a+1) x a^(a+2)^(a+2) a - byte(eth::Instruction::SWAP3), - byte(eth::Instruction::POP), // second ++ + byte(Instruction::SWAP3), + byte(Instruction::POP), // second ++ // Stack here: a x a^(a+2)^(a+2) - byte(eth::Instruction::DUP3), // will change - byte(eth::Instruction::XOR)}); + byte(Instruction::DUP3), // will change + byte(Instruction::XOR)}); // Stack here: a x a^(a+2)^(a+2)^a BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -404,16 +404,16 @@ BOOST_AUTO_TEST_CASE(assignment) bytes code = compileFirstExpression(sourceCode, {}, {{"test", "f", "a"}, {"test", "f", "b"}}); // Stack: a, b - bytes expectation({byte(eth::Instruction::PUSH1), 0x2, - byte(eth::Instruction::DUP2), - byte(eth::Instruction::DUP4), - byte(eth::Instruction::ADD), + bytes expectation({byte(Instruction::PUSH1), 0x2, + byte(Instruction::DUP2), + byte(Instruction::DUP4), + byte(Instruction::ADD), // Stack here: a b 2 a+b - byte(eth::Instruction::SWAP3), - byte(eth::Instruction::POP), - byte(eth::Instruction::DUP3), + byte(Instruction::SWAP3), + byte(Instruction::POP), + byte(Instruction::DUP3), // Stack here: a+b b 2 a+b - byte(eth::Instruction::MUL)}); + byte(Instruction::MUL)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -427,26 +427,26 @@ BOOST_AUTO_TEST_CASE(function_call) {{"test", "f", "a"}, {"test", "f", "b"}}); // Stack: a, b - bytes expectation({byte(eth::Instruction::PUSH1), 0x02, - byte(eth::Instruction::PUSH1), 0x0c, - byte(eth::Instruction::PUSH1), 0x01, - byte(eth::Instruction::DUP5), - byte(eth::Instruction::ADD), + bytes expectation({byte(Instruction::PUSH1), 0x02, + byte(Instruction::PUSH1), 0x0c, + byte(Instruction::PUSH1), 0x01, + byte(Instruction::DUP5), + byte(Instruction::ADD), // Stack here: a b 2 <ret label> (a+1) - byte(eth::Instruction::DUP4), - byte(eth::Instruction::PUSH1), 0x13, - byte(eth::Instruction::JUMP), - byte(eth::Instruction::JUMPDEST), + byte(Instruction::DUP4), + byte(Instruction::PUSH1), 0x13, + byte(Instruction::JUMP), + byte(Instruction::JUMPDEST), // Stack here: a b 2 g(a+1, b) - byte(eth::Instruction::MUL), + byte(Instruction::MUL), // Stack here: a b g(a+1, b)*2 - byte(eth::Instruction::DUP3), - byte(eth::Instruction::ADD), + byte(Instruction::DUP3), + byte(Instruction::ADD), // Stack here: a b a+g(a+1, b)*2 - byte(eth::Instruction::SWAP2), - byte(eth::Instruction::POP), - byte(eth::Instruction::DUP2), - byte(eth::Instruction::JUMPDEST)}); + byte(Instruction::SWAP2), + byte(Instruction::POP), + byte(Instruction::DUP2), + byte(Instruction::JUMPDEST)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -457,7 +457,7 @@ BOOST_AUTO_TEST_CASE(negative_literals_8bits) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation(bytes({byte(eth::Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x80)); + bytes expectation(bytes({byte(Instruction::PUSH32)}) + bytes(31, 0xff) + bytes(1, 0x80)); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -468,7 +468,7 @@ BOOST_AUTO_TEST_CASE(negative_literals_16bits) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation(bytes({byte(eth::Instruction::PUSH32)}) + bytes(30, 0xff) + bytes{0xf5, 0x43}); + bytes expectation(bytes({byte(Instruction::PUSH32)}) + bytes(30, 0xff) + bytes{0xf5, 0x43}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -481,7 +481,7 @@ BOOST_AUTO_TEST_CASE(intermediately_overflowing_literals) "}\n"; bytes code = compileFirstExpression(sourceCode); - bytes expectation(bytes({byte(eth::Instruction::PUSH1), 0xbf})); + bytes expectation(bytes({byte(Instruction::PUSH1), 0xbf})); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } @@ -495,8 +495,8 @@ BOOST_AUTO_TEST_CASE(blockhash) bytes code = compileFirstExpression(sourceCode, {}, {}, {make_shared<MagicVariableDeclaration>("block", make_shared<MagicType>(MagicType::Kind::Block))}); - bytes expectation({byte(eth::Instruction::PUSH1), 0x03, - byte(eth::Instruction::BLOCKHASH)}); + bytes expectation({byte(Instruction::PUSH1), 0x03, + byte(Instruction::BLOCKHASH)}); BOOST_CHECK_EQUAL_COLLECTIONS(code.begin(), code.end(), expectation.begin(), expectation.end()); } diff --git a/test/libsolidity/SolidityOptimizer.cpp b/test/libsolidity/SolidityOptimizer.cpp index 6aa90973..d48c7648 100644 --- a/test/libsolidity/SolidityOptimizer.cpp +++ b/test/libsolidity/SolidityOptimizer.cpp @@ -58,11 +58,11 @@ public: m_optimize = true; bytes optimizedBytecode = compileAndRun(_sourceCode, _value, _contractName); size_t nonOptimizedSize = 0; - eth::eachInstruction(nonOptimizedBytecode, [&](Instruction, u256 const&) { + solidity::eachInstruction(nonOptimizedBytecode, [&](Instruction, u256 const&) { nonOptimizedSize++; }); size_t optimizedSize = 0; - eth::eachInstruction(optimizedBytecode, [&](Instruction, u256 const&) { + solidity::eachInstruction(optimizedBytecode, [&](Instruction, u256 const&) { optimizedSize++; }); BOOST_CHECK_MESSAGE( @@ -308,8 +308,8 @@ BOOST_AUTO_TEST_CASE(retain_information_in_branches) m_optimize = true; bytes optimizedBytecode = compileAndRun(sourceCode, 0, "c"); size_t numSHA3s = 0; - eth::eachInstruction(optimizedBytecode, [&](Instruction _instr, u256 const&) { - if (_instr == eth::Instruction::SHA3) + eachInstruction(optimizedBytecode, [&](Instruction _instr, u256 const&) { + if (_instr == Instruction::SHA3) numSHA3s++; }); BOOST_CHECK_EQUAL(1, numSHA3s); @@ -351,8 +351,8 @@ BOOST_AUTO_TEST_CASE(store_tags_as_unions) m_optimize = true; bytes optimizedBytecode = compileAndRun(sourceCode, 0, "test"); size_t numSHA3s = 0; - eth::eachInstruction(optimizedBytecode, [&](Instruction _instr, u256 const&) { - if (_instr == eth::Instruction::SHA3) + eachInstruction(optimizedBytecode, [&](Instruction _instr, u256 const&) { + if (_instr == Instruction::SHA3) numSHA3s++; }); // TEST DISABLED UNTIL 93693404 IS IMPLEMENTED @@ -1071,16 +1071,16 @@ BOOST_AUTO_TEST_CASE(block_deduplicator) AssemblyItem(PushTag, 1), AssemblyItem(PushTag, 3), u256(6), - eth::Instruction::SWAP3, - eth::Instruction::JUMP, + Instruction::SWAP3, + Instruction::JUMP, AssemblyItem(Tag, 1), u256(6), - eth::Instruction::SWAP3, - eth::Instruction::JUMP, + Instruction::SWAP3, + Instruction::JUMP, AssemblyItem(Tag, 2), u256(6), - eth::Instruction::SWAP3, - eth::Instruction::JUMP, + Instruction::SWAP3, + Instruction::JUMP, AssemblyItem(Tag, 3) }; BlockDeduplicator dedup(input); @@ -1097,23 +1097,23 @@ BOOST_AUTO_TEST_CASE(block_deduplicator_loops) { AssemblyItems input{ u256(0), - eth::Instruction::SLOAD, + Instruction::SLOAD, AssemblyItem(PushTag, 1), AssemblyItem(PushTag, 2), - eth::Instruction::JUMPI, - eth::Instruction::JUMP, + Instruction::JUMPI, + Instruction::JUMP, AssemblyItem(Tag, 1), u256(5), u256(6), - eth::Instruction::SSTORE, + Instruction::SSTORE, AssemblyItem(PushTag, 1), - eth::Instruction::JUMP, + Instruction::JUMP, AssemblyItem(Tag, 2), u256(5), u256(6), - eth::Instruction::SSTORE, + Instruction::SSTORE, AssemblyItem(PushTag, 2), - eth::Instruction::JUMP, + Instruction::JUMP, }; BlockDeduplicator dedup(input); dedup.deduplicate(); |