prettyEscapes{{'\r', 'r'}, {'\n', 'n'}, {'\t', 't'}, {'\v', 'v'}};
std::string ret;
- ret.reserve(_s.size());
+ ret.reserve(_s.size() + 2);
ret.push_back('"');
for (auto i: _s)
if (i == '"' && !_all)
ret += "\\\"";
else if (i == '\\' && !_all)
ret += "\\\\";
+ else if (prettyEscapes.count(i))
+ {
+ ret += '\\';
+ ret += prettyEscapes.find(i)->second;
+ }
else if (i < ' ' || _all)
{
ret += "\\x";
diff --git a/libdevcore/CommonIO.cpp b/libdevcore/CommonIO.cpp
index 3d2eccf13..8fc4fedb3 100644
--- a/libdevcore/CommonIO.cpp
+++ b/libdevcore/CommonIO.cpp
@@ -30,7 +30,7 @@ string dev::memDump(bytes const& _b, unsigned _w, bool _html)
{
stringstream ret;
if (_html)
- ret << "";
+ ret << "";
for (unsigned i = 0; i < _b.size(); i += _w)
{
ret << hex << setw(4) << setfill('0') << i << " ";
diff --git a/libdevcore/Log.h b/libdevcore/Log.h
index 704660276..2e111332c 100644
--- a/libdevcore/Log.h
+++ b/libdevcore/Log.h
@@ -27,6 +27,7 @@
#include
#include
#include "vector_ref.h"
+#include "CommonIO.h"
namespace dev
{
diff --git a/libdevcore/RLP.h b/libdevcore/RLP.h
index 248a2e645..3101f63d6 100644
--- a/libdevcore/RLP.h
+++ b/libdevcore/RLP.h
@@ -158,8 +158,13 @@ public:
/// Best-effort conversion operators.
explicit operator std::string() const { return toString(); }
+ explicit operator bytes() const { return toBytes(); }
explicit operator RLPs() const { return toList(); }
- explicit operator byte() const { return toInt(); }
+ explicit operator uint8_t() const { return toInt(); }
+ explicit operator uint16_t() const { return toInt(); }
+ explicit operator uint32_t() const { return toInt(); }
+ explicit operator uint64_t() const { return toInt(); }
+ explicit operator u160() const { return toInt(); }
explicit operator u256() const { return toInt(); }
explicit operator bigint() const { return toInt(); }
template explicit operator FixedHash<_N>() const { return toHash>(); }
@@ -337,7 +342,7 @@ public:
RLPStream& append(char const* _s) { return append(std::string(_s)); }
template RLPStream& append(FixedHash _s, bool _compact = false, bool _allOrNothing = false) { return _allOrNothing && !_s ? append(bytesConstRef()) : append(_s.ref(), _compact); }
- /// Appends an arbitrary RLP fragment - this *must* be a single item.
+ /// Appends an arbitrary RLP fragment - this *must* be a single item unless @a _itemCount is given.
RLPStream& append(RLP const& _rlp, unsigned _itemCount = 1) { return appendRaw(_rlp.data(), _itemCount); }
/// Appends a sequence of data to the stream as a list.
diff --git a/libdevcrypto/Common.cpp b/libdevcrypto/Common.cpp
index d82098655..2db65aae3 100644
--- a/libdevcrypto/Common.cpp
+++ b/libdevcrypto/Common.cpp
@@ -21,6 +21,7 @@
*/
#include
+#include
#include
#include "EC.h"
#include "SHA3.h"
@@ -39,7 +40,7 @@ Address dev::toAddress(Secret _secret)
KeyPair KeyPair::create()
{
- static mt19937_64 s_eng(time(0));
+ static mt19937_64 s_eng(time(0) + chrono::high_resolution_clock::now().time_since_epoch().count());
uniform_int_distribution d(0, 255);
for (int i = 0; i < 100; ++i)
diff --git a/libdevcrypto/EC.cpp b/libdevcrypto/EC.cpp
index 7bc17ab99..e6e6d2329 100644
--- a/libdevcrypto/EC.cpp
+++ b/libdevcrypto/EC.cpp
@@ -37,6 +37,8 @@ using namespace dev::crypto;
using namespace CryptoPP;
using namespace pp;
+static const int c_publicKeySize = 65; // Public key size for I/O is 65 bytes (there's an extra byte that we don't really need).
+
void crypto::toPublic(Secret const& _s, Public& o_public)
{
exponentToPublic(Integer(_s.data(), sizeof(_s)), o_public);
@@ -134,16 +136,16 @@ bool crypto::verify(Signature const& _signature, bytesConstRef _message)
bool crypto::verify(Public const& _p, Signature const& _sig, bytesConstRef _message, bool _hashed)
{
- static const size_t derMaxEncodingLength = 72;
+ static const size_t c_derMaxEncodingLength = 72;
if (_hashed)
{
assert(_message.size() == 32);
byte encpub[65] = {0x04};
memcpy(&encpub[1], _p.data(), 64);
- byte dersig[derMaxEncodingLength];
- size_t cssz = DSAConvertSignatureFormat(dersig, derMaxEncodingLength, DSA_DER, _sig.data(), 64, DSA_P1363);
- assert(cssz <= derMaxEncodingLength);
- return (1 == secp256k1_ecdsa_verify(_message.data(), _message.size(), dersig, cssz, encpub, 65));
+ byte dersig[c_derMaxEncodingLength];
+ size_t cssz = DSAConvertSignatureFormat(dersig, c_derMaxEncodingLength, DSA_DER, _sig.data(), 64, DSA_P1363);
+ assert(cssz <= c_derMaxEncodingLength);
+ return (1 == secp256k1_ecdsa_verify(_message.data(), _message.size(), dersig, cssz, encpub, c_publicKeySize));
}
ECDSA::Verifier verifier;
@@ -155,10 +157,9 @@ Public crypto::recover(Signature _signature, bytesConstRef _message)
{
secp256k1_start();
- static const int c_pubkeylen = 65;
- auto pubkeylen = c_pubkeylen;
- byte pubkey[c_pubkeylen];
- if (!secp256k1_ecdsa_recover_compact(_message.data(), 32, _signature.data(), pubkey, &pubkeylen, 0, (int)_signature[64]))
+ byte pubkey[c_publicKeySize];
+ int keySize;
+ if (!secp256k1_ecdsa_recover_compact(_message.data(), 32, _signature.data(), pubkey, &keySize, 0, (int)_signature[64]) || keySize != c_publicKeySize)
return Public();
#if ETH_CRYPTO_TRACE
@@ -181,14 +182,14 @@ bool crypto::verifySecret(Secret const& _s, Public const& _p)
if (!ok)
return false;
- static const int c_pubkeylen = 65;
- auto pubkeylen = c_pubkeylen;
- byte pubkey[c_pubkeylen];
- ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, _s.data(), 0);
- if (!ok || pubkeylen != 65)
+ byte pubkey[c_publicKeySize];
+
+ int keySize;
+ ok = secp256k1_ecdsa_pubkey_create(pubkey, &keySize, _s.data(), 0);
+ if (!ok || keySize != c_publicKeySize)
return false;
- ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65);
+ ok = secp256k1_ecdsa_pubkey_verify(pubkey, c_publicKeySize);
if (!ok)
return false;
diff --git a/libethcore/CommonEth.cpp b/libethcore/CommonEth.cpp
index 8e21884ee..3c0a93481 100644
--- a/libethcore/CommonEth.cpp
+++ b/libethcore/CommonEth.cpp
@@ -34,7 +34,7 @@ namespace dev
namespace eth
{
-const unsigned c_protocolVersion = 39;
+const unsigned c_protocolVersion = 42;
const unsigned c_databaseVersion = 4;
static const vector> g_units =
diff --git a/libethereum/Executive.cpp b/libethereum/Executive.cpp
index 2a28f99ed..30676765f 100644
--- a/libethereum/Executive.cpp
+++ b/libethereum/Executive.cpp
@@ -80,14 +80,14 @@ bool Executive::setup(bytesConstRef _rlp)
if (m_s.balance(m_sender) < cost)
{
clog(StateDetail) << "Not enough cash: Require >" << cost << " Got" << m_s.balance(m_sender);
- BOOST_THROW_EXCEPTION(NotEnoughCash());
+ BOOST_THROW_EXCEPTION(NotEnoughCash() << RequirementError((int)cost, (int)m_s.balance(m_sender)));
}
u256 startGasUsed = m_s.gasUsed();
if (startGasUsed + m_t.gas() > m_s.m_currentBlock.gasLimit)
{
clog(StateDetail) << "Too much gas used in this block: Require <" << (m_s.m_currentBlock.gasLimit - startGasUsed) << " Got" << m_t.gas();
- BOOST_THROW_EXCEPTION(BlockGasLimitReached());
+ BOOST_THROW_EXCEPTION(BlockGasLimitReached() << RequirementError((int)(m_s.m_currentBlock.gasLimit - startGasUsed), (int)m_t.gas()));
}
// Increment associated nonce for sender.
@@ -123,11 +123,7 @@ bool Executive::call(Address _receiveAddress, Address _senderAddress, u256 _valu
m_ext = new ExtVM(m_s, _receiveAddress, _senderAddress, _originAddress, _value, _gasPrice, _data, &c, m_ms);
}
else
- {
m_endGas = _gas;
- if (m_ext)
- m_ext->sub.logs.push_back(LogEntry(_receiveAddress, {u256((u160)_senderAddress) + 1}, bytes()));
- }
return !m_ext;
}
@@ -177,7 +173,10 @@ bool Executive::go(OnOpFunc const& _onOp)
{
m_out = m_vm->go(*m_ext, _onOp);
if (m_ext)
+ {
m_endGas += min((m_t.gas() - m_endGas) / 2, m_ext->sub.refunds);
+ m_logs = m_ext->sub.logs;
+ }
m_endGas = m_vm->gas();
}
catch (StepsDone const&)
diff --git a/libethereum/Executive.h b/libethereum/Executive.h
index 79b58d252..1a9a27d52 100644
--- a/libethereum/Executive.h
+++ b/libethereum/Executive.h
@@ -23,7 +23,7 @@
#include
#include
-#include
+#include
#include
#include "Transaction.h"
#include "Manifest.h"
diff --git a/libethereum/ExtVM.h b/libethereum/ExtVM.h
index 758672e49..24ce618ed 100644
--- a/libethereum/ExtVM.h
+++ b/libethereum/ExtVM.h
@@ -40,7 +40,7 @@ class ExtVM: public ExtVMFace
public:
/// Full constructor.
ExtVM(State& _s, Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytesConstRef _code, Manifest* o_ms, unsigned _depth = 0):
- ExtVMFace(_myAddress, _caller, _origin, _value, _gasPrice, _data, _code, _s.m_previousBlock, _s.m_currentBlock, _depth), m_s(_s), m_origCache(_s.m_cache), m_ms(o_ms)
+ ExtVMFace(_myAddress, _caller, _origin, _value, _gasPrice, _data, _code.toBytes(), _s.m_previousBlock, _s.m_currentBlock, _depth), m_s(_s), m_origCache(_s.m_cache), m_ms(o_ms)
{
m_s.ensureCached(_myAddress, true, true);
}
diff --git a/libethereum/State.cpp b/libethereum/State.cpp
index 4cfe66cc1..2645e228b 100644
--- a/libethereum/State.cpp
+++ b/libethereum/State.cpp
@@ -21,12 +21,13 @@
#include "State.h"
-#include
-#include
+#include
#include
+#include
+#include
#include
#include
-#include
+#include
#include
#include
#include "BlockChain.h"
@@ -555,10 +556,12 @@ h256s State::sync(TransactionQueue& _tq, bool* o_transactionQueueChanged)
try
{
uncommitToMine();
+// boost::timer t;
execute(i.second);
ret.push_back(m_receipts.back().changes().bloom());
_tq.noteGood(i);
++goodTxs;
+// cnote << "TX took:" << t.elapsed() * 1000;
}
catch (InvalidNonce const& in)
{
@@ -1196,11 +1199,14 @@ bool State::call(Address _receiveAddress, Address _codeAddress, Address _senderA
auto it = !(_codeAddress & ~h160(0xffffffff)) ? c_precompiled.find((unsigned)(u160)_codeAddress) : c_precompiled.end();
if (it != c_precompiled.end())
{
- if (*_gas >= it->second.gas)
+ if (*_gas < it->second.gas)
{
- *_gas -= it->second.gas;
- it->second.exec(_data, _out);
+ *_gas = 0;
+ return false;
}
+
+ *_gas -= it->second.gas;
+ it->second.exec(_data, _out);
}
else if (addressHasCode(_codeAddress))
{
@@ -1242,12 +1248,6 @@ bool State::call(Address _receiveAddress, Address _codeAddress, Address _senderA
return !revert;
}
- else
- {
- // non-contract call
- if (o_sub)
- o_sub->logs.push_back(LogEntry(_receiveAddress, {u256((u160)_senderAddress) + 1}, bytes()));
- }
return true;
}
diff --git a/libethereum/TransactionReceipt.h b/libethereum/TransactionReceipt.h
index 26539c4a9..e24c224e7 100644
--- a/libethereum/TransactionReceipt.h
+++ b/libethereum/TransactionReceipt.h
@@ -55,6 +55,8 @@ public:
l.streamRLP(_s);
}
+ bytes rlp() const { RLPStream s; streamRLP(s); return s.out(); }
+
private:
h256 m_stateRoot;
u256 m_gasUsed;
diff --git a/libevm/CMakeLists.txt b/libevm/CMakeLists.txt
index 0c31a9fc3..b4aa1eef2 100644
--- a/libevm/CMakeLists.txt
+++ b/libevm/CMakeLists.txt
@@ -17,7 +17,7 @@ include_directories(..)
target_link_libraries(${EXECUTABLE} ethcore)
target_link_libraries(${EXECUTABLE} devcrypto)
-target_link_libraries(${EXECUTABLE} evmface)
+target_link_libraries(${EXECUTABLE} evmcore)
target_link_libraries(${EXECUTABLE} devcore)
target_link_libraries(${EXECUTABLE} secp256k1)
target_link_libraries(${EXECUTABLE} gmp)
diff --git a/libevm/ExtVMFace.cpp b/libevm/ExtVMFace.cpp
index da189d899..8a08a290c 100644
--- a/libevm/ExtVMFace.cpp
+++ b/libevm/ExtVMFace.cpp
@@ -25,7 +25,7 @@ using namespace std;
using namespace dev;
using namespace dev::eth;
-ExtVMFace::ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytesConstRef _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, unsigned _depth):
+ExtVMFace::ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytes const& _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, unsigned _depth):
myAddress(_myAddress),
caller(_caller),
origin(_origin),
diff --git a/libevm/ExtVMFace.h b/libevm/ExtVMFace.h
index 62132a462..65761e410 100644
--- a/libevm/ExtVMFace.h
+++ b/libevm/ExtVMFace.h
@@ -27,7 +27,7 @@
#include
#include
#include
-#include
+#include
#include
#include
@@ -49,7 +49,7 @@ using LogBloom = h512;
struct LogEntry
{
LogEntry() {}
- LogEntry(RLP const& _r) { address = (Address)_r[0]; topics = (h256Set)_r[1]; data = (bytes)_r[2]; }
+ LogEntry(RLP const& _r) { address = (Address)_r[0]; topics = (h256Set)_r[1]; data = _r[2].toBytes(); }
LogEntry(Address const& _address, h256s const& _ts, bytes&& _d): address(_address), topics(toSet(_ts)), data(std::move(_d)) {}
void streamRLP(RLPStream& _s) const { _s.appendList(3) << address << topics << data; }
@@ -104,7 +104,7 @@ public:
ExtVMFace() = default;
/// Full constructor.
- ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytesConstRef _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, unsigned _depth);
+ ExtVMFace(Address _myAddress, Address _caller, Address _origin, u256 _value, u256 _gasPrice, bytesConstRef _data, bytes const& _code, BlockInfo const& _previousBlock, BlockInfo const& _currentBlock, unsigned _depth);
virtual ~ExtVMFace() = default;
@@ -153,7 +153,7 @@ public:
u256 value; ///< Value (in Wei) that was passed to this address.
u256 gasPrice; ///< Price of gas (that we already paid).
bytesConstRef data; ///< Current input data.
- bytesConstRef code; ///< Current code that is executing.
+ bytes code; ///< Current code that is executing.
BlockInfo previousBlock; ///< The previous block's information.
BlockInfo currentBlock; ///< The current block's information.
SubState sub; ///< Sub-band VM state (suicides, refund counter, logs).
diff --git a/libevm/FeeStructure.cpp b/libevm/FeeStructure.cpp
index 47236b506..6d868cac5 100644
--- a/libevm/FeeStructure.cpp
+++ b/libevm/FeeStructure.cpp
@@ -37,3 +37,6 @@ u256 const dev::eth::c_callGas = 20;
u256 const dev::eth::c_memoryGas = 1;
u256 const dev::eth::c_txDataGas = 5;
u256 const dev::eth::c_txGas = 500;
+u256 const dev::eth::c_logGas = 32;
+u256 const dev::eth::c_logDataGas = 1;
+u256 const dev::eth::c_logTopicGas = 32;
diff --git a/libevm/FeeStructure.h b/libevm/FeeStructure.h
index 84a2551d9..e57f7ccf8 100644
--- a/libevm/FeeStructure.h
+++ b/libevm/FeeStructure.h
@@ -40,6 +40,9 @@ extern u256 const c_callGas; ///< Once per CALL operation & message call trans
extern u256 const c_memoryGas; ///< Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
extern u256 const c_txDataGas; ///< Per byte of data attached to a transaction. NOTE: Not payable on data of calls between transactions.
extern u256 const c_txGas; ///< Per transaction. NOTE: Not payable on data of calls between transactions.
+extern u256 const c_logGas; ///< Per LOG* operation.
+extern u256 const c_logDataGas; ///< Per byte in a LOG* operation's data.
+extern u256 const c_logTopicGas; ///< Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
}
}
diff --git a/libevm/VM.h b/libevm/VM.h
index 3f67ce902..73d80b944 100644
--- a/libevm/VM.h
+++ b/libevm/VM.h
@@ -24,7 +24,7 @@
#include
#include
#include
-#include
+#include
#include
#include
#include "VMFace.h"
@@ -184,14 +184,15 @@ template dev::bytesConstRef dev::eth::VM::go(Ext& _ext, OnOpFunc con
{
unsigned n = (unsigned)inst - (unsigned)Instruction::LOG0;
require(n + 2);
- newTempSize = memNeed(m_stack[m_stack.size() - 1 - n], m_stack[m_stack.size() - 2 - n]);
+ runGas = c_logGas + c_logTopicGas * n + (bigint)c_logDataGas * m_stack[m_stack.size() - 2];
+ newTempSize = memNeed(m_stack[m_stack.size() - 1], m_stack[m_stack.size() - 2]);
break;
}
case Instruction::CALL:
case Instruction::CALLCODE:
require(7);
- runGas = c_callGas + m_stack[m_stack.size() - 1];
+ runGas = (bigint)c_callGas + m_stack[m_stack.size() - 1];
newTempSize = std::max(memNeed(m_stack[m_stack.size() - 6], m_stack[m_stack.size() - 7]), memNeed(m_stack[m_stack.size() - 4], m_stack[m_stack.size() - 5]));
break;
@@ -679,7 +680,7 @@ template dev::bytesConstRef dev::eth::VM::go(Ext& _ext, OnOpFunc con
break;
case Instruction::JUMP:
nextPC = m_stack.back();
- if (!m_jumpDests.count((unsigned)nextPC))
+ if (!m_jumpDests.count(nextPC))
BOOST_THROW_EXCEPTION(BadJumpDestination());
m_stack.pop_back();
break;
@@ -687,7 +688,7 @@ template dev::bytesConstRef dev::eth::VM::go(Ext& _ext, OnOpFunc con
if (m_stack[m_stack.size() - 2])
{
nextPC = m_stack.back();
- if (!m_jumpDests.count((unsigned)nextPC))
+ if (!m_jumpDests.count(nextPC))
BOOST_THROW_EXCEPTION(BadJumpDestination());
}
m_stack.pop_back();
@@ -721,18 +722,38 @@ template dev::bytesConstRef dev::eth::VM::go(Ext& _ext, OnOpFunc con
break;*/
case Instruction::LOG0:
_ext.log({}, bytesConstRef(m_temp.data() + (unsigned)m_stack[m_stack.size() - 1], (unsigned)m_stack[m_stack.size() - 2]));
+ m_stack.pop_back();
+ m_stack.pop_back();
break;
case Instruction::LOG1:
_ext.log({m_stack[m_stack.size() - 3]}, bytesConstRef(m_temp.data() + (unsigned)m_stack[m_stack.size() - 1], (unsigned)m_stack[m_stack.size() - 2]));
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
break;
case Instruction::LOG2:
_ext.log({m_stack[m_stack.size() - 3], m_stack[m_stack.size() - 4]}, bytesConstRef(m_temp.data() + (unsigned)m_stack[m_stack.size() - 1], (unsigned)m_stack[m_stack.size() - 2]));
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
break;
case Instruction::LOG3:
_ext.log({m_stack[m_stack.size() - 3], m_stack[m_stack.size() - 4], m_stack[m_stack.size() - 5]}, bytesConstRef(m_temp.data() + (unsigned)m_stack[m_stack.size() - 1], (unsigned)m_stack[m_stack.size() - 2]));
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
break;
case Instruction::LOG4:
_ext.log({m_stack[m_stack.size() - 3], m_stack[m_stack.size() - 4], m_stack[m_stack.size() - 5], m_stack[m_stack.size() - 6]}, bytesConstRef(m_temp.data() + (unsigned)m_stack[m_stack.size() - 1], (unsigned)m_stack[m_stack.size() - 2]));
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
+ m_stack.pop_back();
break;
case Instruction::CREATE:
{
diff --git a/liblll/Assembly.cpp b/libevmcore/Assembly.cpp
similarity index 82%
rename from liblll/Assembly.cpp
rename to libevmcore/Assembly.cpp
index d4f6c0a73..4725c8c1a 100644
--- a/liblll/Assembly.cpp
+++ b/libevmcore/Assembly.cpp
@@ -70,7 +70,12 @@ unsigned Assembly::bytesRequired() const
case PushData:
case PushSub:
ret += 1 + br;
- default:;
+ break;
+ case NoOptimizeBegin:
+ case NoOptimizeEnd:
+ break;
+ default:
+ BOOST_THROW_EXCEPTION(InvalidOpcode());
}
if (dev::bytesRequired(ret) <= br)
return ret;
@@ -140,9 +145,17 @@ ostream& dev::eth::operator<<(ostream& _out, AssemblyItemsConstRef _i)
case PushSubSize:
_out << " PUSHss[" << hex << h256(i.data()).abridged() << "]";
break;
+ case NoOptimizeBegin:
+ _out << " DoNotOptimze{{";
+ break;
+ case NoOptimizeEnd:
+ _out << " DoNotOptimze}}";
+ break;
case UndefinedItem:
_out << " ???";
- default:;
+ break;
+ default:
+ BOOST_THROW_EXCEPTION(InvalidOpcode());
}
return _out;
}
@@ -177,7 +190,14 @@ ostream& Assembly::streamRLP(ostream& _out, string const& _prefix) const
case PushData:
_out << _prefix << " PUSH [" << hex << (unsigned)i.m_data << "]" << endl;
break;
- default:;
+ case NoOptimizeBegin:
+ _out << _prefix << "DoNotOptimze{{" << endl;
+ break;
+ case NoOptimizeEnd:
+ _out << _prefix << "DoNotOptimze}}" << endl;
+ break;
+ default:
+ BOOST_THROW_EXCEPTION(InvalidOpcode());
}
if (m_data.size() || m_subs.size())
@@ -217,6 +237,12 @@ inline bool matches(AssemblyItemsConstRef _a, AssemblyItemsConstRef _b)
return true;
}
+inline bool popCountIncreased(AssemblyItemsConstRef _pre, AssemblyItems const& _post)
+{
+ auto isPop = [](AssemblyItem const& _item) -> bool { return _item.match(AssemblyItem(Instruction::POP)); };
+ return count_if(begin(_post), end(_post), isPop) > count_if(begin(_pre), end(_pre), isPop);
+}
+
struct OptimiserChannel: public LogChannel { static const char* name() { return "OPT"; } static const int verbosity = 12; };
#define copt dev::LogOutputStream()
@@ -224,6 +250,14 @@ Assembly& Assembly::optimise(bool _enable)
{
if (!_enable)
return *this;
+ auto signextend = [](u256 a, u256 b) -> u256
+ {
+ if (a >= 31)
+ return b;
+ unsigned testBit = unsigned(a) * 8 + 7;
+ u256 mask = (u256(1) << testBit) - 1;
+ return boost::multiprecision::bit_test(b, testBit) ? b | ~mask : b & mask;
+ };
map> c_simple =
{
{ Instruction::SUB, [](u256 a, u256 b)->u256{return a - b;} },
@@ -232,6 +266,7 @@ Assembly& Assembly::optimise(bool _enable)
{ Instruction::MOD, [](u256 a, u256 b)->u256{return a % b;} },
{ Instruction::SMOD, [](u256 a, u256 b)->u256{return s2u(u2s(a) % u2s(b));} },
{ Instruction::EXP, [](u256 a, u256 b)->u256{return (u256)boost::multiprecision::powm((bigint)a, (bigint)b, bigint(2) << 256);} },
+ { Instruction::SIGNEXTEND, signextend },
{ Instruction::LT, [](u256 a, u256 b)->u256{return a < b ? 1 : 0;} },
{ Instruction::GT, [](u256 a, u256 b)->u256{return a > b ? 1 : 0;} },
{ Instruction::SLT, [](u256 a, u256 b)->u256{return u2s(a) < u2s(b) ? 1 : 0;} },
@@ -242,6 +277,9 @@ Assembly& Assembly::optimise(bool _enable)
{
{ Instruction::ADD, [](u256 a, u256 b)->u256{return a + b;} },
{ Instruction::MUL, [](u256 a, u256 b)->u256{return a * b;} },
+ { Instruction::AND, [](u256 a, u256 b)->u256{return a & b;} },
+ { Instruction::OR, [](u256 a, u256 b)->u256{return a | b;} },
+ { Instruction::XOR, [](u256 a, u256 b)->u256{return a ^ b;} },
};
std::vector>> rules =
{
@@ -260,8 +298,23 @@ Assembly& Assembly::optimise(bool _enable)
{
rules.push_back({ { Push, Push, i.first }, [&](AssemblyItemsConstRef m) -> AssemblyItems { return { i.second(m[1].data(), m[0].data()) }; } });
rules.push_back({ { Push, i.first, Push, i.first }, [&](AssemblyItemsConstRef m) -> AssemblyItems { return { i.second(m[2].data(), m[0].data()), i.first }; } });
- rules.push_back({ { PushTag, Instruction::JUMP, Tag }, [&](AssemblyItemsConstRef m) -> AssemblyItems { if (m[0].m_data == m[2].m_data) return {}; else return m.toVector(); }});
}
+ // jump to next instruction
+ rules.push_back({ { PushTag, Instruction::JUMP, Tag }, [&](AssemblyItemsConstRef m) -> AssemblyItems { if (m[0].m_data == m[2].m_data) return {m[2]}; else return m.toVector(); }});
+
+ // pop optimization, do not compute values that are popped again anyway
+ rules.push_back({ { AssemblyItem(UndefinedItem), Instruction::POP }, [](AssemblyItemsConstRef m) -> AssemblyItems
+ {
+ if (m[0].type() != Operation)
+ return m.toVector();
+ Instruction instr = Instruction(byte(m[0].data()));
+ if (Instruction::DUP1 <= instr && instr <= Instruction::DUP16)
+ return {};
+ InstructionInfo info = instructionInfo(instr);
+ if (info.sideEffects || info.additional != 0 || info.ret != 1)
+ return m.toVector();
+ return AssemblyItems(info.args, Instruction::POP);
+ } });
copt << *this;
@@ -269,16 +322,21 @@ Assembly& Assembly::optimise(bool _enable)
for (unsigned count = 1; count > 0; total += count)
{
count = 0;
- map tags;
for (unsigned i = 0; i < m_items.size(); ++i)
{
+ if (m_items[i].type() == NoOptimizeBegin)
+ {
+ while (i < m_items.size() && m_items[i].type() != NoOptimizeEnd)
+ ++i;
+ continue;
+ }
for (auto const& r: rules)
{
auto vr = AssemblyItemsConstRef(&m_items).cropped(i, r.first.size());
- if (matches(&r.first, vr))
+ if (matches(vr, &r.first))
{
auto rw = r.second(vr);
- if (rw.size() < vr.size())
+ if (rw.size() < vr.size() || (rw.size() == vr.size() && popCountIncreased(vr, rw)))
{
copt << vr << "matches" << AssemblyItemsConstRef(&r.first) << "becomes...";
for (unsigned j = 0; j < vr.size(); ++j)
@@ -297,6 +355,8 @@ Assembly& Assembly::optimise(bool _enable)
bool o = false;
while (m_items.size() > i + 1 && m_items[i + 1].type() != Tag)
{
+ if (m_items[i + 1].type() == NoOptimizeBegin)
+ break;
m_items.erase(m_items.begin() + i + 1);
o = true;
}
@@ -308,6 +368,7 @@ Assembly& Assembly::optimise(bool _enable)
}
}
+ map tags;
for (unsigned i = 0; i < m_items.size(); ++i)
if (m_items[i].type() == Tag)
tags.insert(make_pair(m_items[i].data(), i));
@@ -416,7 +477,11 @@ bytes Assembly::assemble() const
tagPos[(unsigned)i.m_data] = ret.size();
ret.push_back((byte)Instruction::JUMPDEST);
break;
- default:;
+ case NoOptimizeBegin:
+ case NoOptimizeEnd:
+ break;
+ default:
+ BOOST_THROW_EXCEPTION(InvalidOpcode());
}
for (auto const& i: tagRef)
diff --git a/liblll/Assembly.h b/libevmcore/Assembly.h
similarity index 97%
rename from liblll/Assembly.h
rename to libevmcore/Assembly.h
index e39f1899b..b8e59a474 100644
--- a/liblll/Assembly.h
+++ b/libevmcore/Assembly.h
@@ -24,7 +24,7 @@
#include
#include
#include
-#include
+#include
#include "Exceptions.h"
namespace dev
@@ -32,7 +32,7 @@ namespace dev
namespace eth
{
-enum AssemblyItemType { UndefinedItem, Operation, Push, PushString, PushTag, PushSub, PushSubSize, Tag, PushData };
+enum AssemblyItemType { UndefinedItem, Operation, Push, PushString, PushTag, PushSub, PushSubSize, Tag, PushData, NoOptimizeBegin, NoOptimizeEnd };
class Assembly;
diff --git a/libevmface/CMakeLists.txt b/libevmcore/CMakeLists.txt
similarity index 95%
rename from libevmface/CMakeLists.txt
rename to libevmcore/CMakeLists.txt
index f82d2b96b..738303271 100644
--- a/libevmface/CMakeLists.txt
+++ b/libevmcore/CMakeLists.txt
@@ -4,7 +4,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSTATICLIB")
aux_source_directory(. SRC_LIST)
-set(EXECUTABLE evmface)
+set(EXECUTABLE evmcore)
file(GLOB HEADERS "*.h")
if(ETH_STATIC)
diff --git a/libevmcore/Exceptions.h b/libevmcore/Exceptions.h
new file mode 100644
index 000000000..57e1ac9c6
--- /dev/null
+++ b/libevmcore/Exceptions.h
@@ -0,0 +1,36 @@
+/*
+ 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 .
+*/
+/** @file Exceptions.h
+ * @author Christian
+ * @date 2014
+ */
+
+#pragma once
+
+#include
+
+namespace dev
+{
+namespace eth
+{
+
+struct AssemblyException: virtual Exception {};
+struct InvalidDeposit: virtual AssemblyException {};
+struct InvalidOpcode: virtual AssemblyException {};
+
+}
+}
diff --git a/libevmcore/Instruction.cpp b/libevmcore/Instruction.cpp
new file mode 100644
index 000000000..9062fd8ed
--- /dev/null
+++ b/libevmcore/Instruction.cpp
@@ -0,0 +1,337 @@
+/*
+ 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 .
+*/
+/** @file Instruction.cpp
+ * @author Gav Wood
+ * @date 2014
+ */
+
+#include "Instruction.h"
+
+#include
+#include
+#include
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+const std::map dev::eth::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 },
+ { "PREVHASH", Instruction::PREVHASH },
+ { "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 },
+ { "SUICIDE", Instruction::SUICIDE }
+};
+
+static const std::map c_instructionInfo =
+{ // Add, Args, Ret, SideEffects
+ { Instruction::STOP, { "STOP", 0, 0, 0, true } },
+ { Instruction::ADD, { "ADD", 0, 2, 1, false } },
+ { Instruction::SUB, { "SUB", 0, 2, 1, false } },
+ { Instruction::MUL, { "MUL", 0, 2, 1, false } },
+ { Instruction::DIV, { "DIV", 0, 2, 1, false } },
+ { Instruction::SDIV, { "SDIV", 0, 2, 1, false } },
+ { Instruction::MOD, { "MOD", 0, 2, 1, false } },
+ { Instruction::SMOD, { "SMOD", 0, 2, 1, false } },
+ { Instruction::EXP, { "EXP", 0, 2, 1, false } },
+ { Instruction::NOT, { "NOT", 0, 1, 1, false } },
+ { Instruction::LT, { "LT", 0, 2, 1, false } },
+ { Instruction::GT, { "GT", 0, 2, 1, false } },
+ { Instruction::SLT, { "SLT", 0, 2, 1, false } },
+ { Instruction::SGT, { "SGT", 0, 2, 1, false } },
+ { Instruction::EQ, { "EQ", 0, 2, 1, false } },
+ { Instruction::ISZERO, { "ISZERO", 0, 1, 1, false } },
+ { Instruction::AND, { "AND", 0, 2, 1, false } },
+ { Instruction::OR, { "OR", 0, 2, 1, false } },
+ { Instruction::XOR, { "XOR", 0, 2, 1, false } },
+ { Instruction::BYTE, { "BYTE", 0, 2, 1, false } },
+ { Instruction::ADDMOD, { "ADDMOD", 0, 3, 1, false } },
+ { Instruction::MULMOD, { "MULMOD", 0, 3, 1, false } },
+ { Instruction::SIGNEXTEND, { "SIGNEXTEND", 0, 2, 1, false } },
+ { Instruction::SHA3, { "SHA3", 0, 2, 1, false } },
+ { Instruction::ADDRESS, { "ADDRESS", 0, 0, 1, false } },
+ { Instruction::BALANCE, { "BALANCE", 0, 1, 1, false } },
+ { Instruction::ORIGIN, { "ORIGIN", 0, 0, 1, false } },
+ { Instruction::CALLER, { "CALLER", 0, 0, 1, false } },
+ { Instruction::CALLVALUE, { "CALLVALUE", 0, 0, 1, false } },
+ { Instruction::CALLDATALOAD,{ "CALLDATALOAD", 0, 1, 1, false } },
+ { Instruction::CALLDATASIZE,{ "CALLDATASIZE", 0, 0, 1, false } },
+ { Instruction::CALLDATACOPY,{ "CALLDATACOPY", 0, 3, 0, true } },
+ { Instruction::CODESIZE, { "CODESIZE", 0, 0, 1, false } },
+ { Instruction::CODECOPY, { "CODECOPY", 0, 3, 0, true } },
+ { Instruction::GASPRICE, { "GASPRICE", 0, 0, 1, false } },
+ { Instruction::EXTCODESIZE, { "EXTCODESIZE", 0, 1, 1, false } },
+ { Instruction::EXTCODECOPY, { "EXTCODECOPY", 0, 4, 0, true } },
+ { Instruction::PREVHASH, { "PREVHASH", 0, 0, 1, false } },
+ { Instruction::COINBASE, { "COINBASE", 0, 0, 1, false } },
+ { Instruction::TIMESTAMP, { "TIMESTAMP", 0, 0, 1, false } },
+ { Instruction::NUMBER, { "NUMBER", 0, 0, 1, false } },
+ { Instruction::DIFFICULTY, { "DIFFICULTY", 0, 0, 1, false } },
+ { Instruction::GASLIMIT, { "GASLIMIT", 0, 0, 1, false } },
+ { Instruction::POP, { "POP", 0, 1, 0, false } },
+ { Instruction::MLOAD, { "MLOAD", 0, 1, 1, false } },
+ { Instruction::MSTORE, { "MSTORE", 0, 2, 0, true } },
+ { Instruction::MSTORE8, { "MSTORE8", 0, 2, 0, true } },
+ { Instruction::SLOAD, { "SLOAD", 0, 1, 1, false } },
+ { Instruction::SSTORE, { "SSTORE", 0, 2, 0, true } },
+ { Instruction::JUMP, { "JUMP", 0, 1, 0, true } },
+ { Instruction::JUMPI, { "JUMPI", 0, 2, 0, true } },
+ { Instruction::PC, { "PC", 0, 0, 1, false } },
+ { Instruction::MSIZE, { "MSIZE", 0, 0, 1, false } },
+ { Instruction::GAS, { "GAS", 0, 0, 1, false } },
+ { Instruction::JUMPDEST, { "JUMPDEST", 0, 1, 0, true } },
+ { Instruction::PUSH1, { "PUSH1", 1, 0, 1, false } },
+ { Instruction::PUSH2, { "PUSH2", 2, 0, 1, false } },
+ { Instruction::PUSH3, { "PUSH3", 3, 0, 1, false } },
+ { Instruction::PUSH4, { "PUSH4", 4, 0, 1, false } },
+ { Instruction::PUSH5, { "PUSH5", 5, 0, 1, false } },
+ { Instruction::PUSH6, { "PUSH6", 6, 0, 1, false } },
+ { Instruction::PUSH7, { "PUSH7", 7, 0, 1, false } },
+ { Instruction::PUSH8, { "PUSH8", 8, 0, 1, false } },
+ { Instruction::PUSH9, { "PUSH9", 9, 0, 1, false } },
+ { Instruction::PUSH10, { "PUSH10", 10, 0, 1, false } },
+ { Instruction::PUSH11, { "PUSH11", 11, 0, 1, false } },
+ { Instruction::PUSH12, { "PUSH12", 12, 0, 1, false } },
+ { Instruction::PUSH13, { "PUSH13", 13, 0, 1, false } },
+ { Instruction::PUSH14, { "PUSH14", 14, 0, 1, false } },
+ { Instruction::PUSH15, { "PUSH15", 15, 0, 1, false } },
+ { Instruction::PUSH16, { "PUSH16", 16, 0, 1, false } },
+ { Instruction::PUSH17, { "PUSH17", 17, 0, 1, false } },
+ { Instruction::PUSH18, { "PUSH18", 18, 0, 1, false } },
+ { Instruction::PUSH19, { "PUSH19", 19, 0, 1, false } },
+ { Instruction::PUSH20, { "PUSH20", 20, 0, 1, false } },
+ { Instruction::PUSH21, { "PUSH21", 21, 0, 1, false } },
+ { Instruction::PUSH22, { "PUSH22", 22, 0, 1, false } },
+ { Instruction::PUSH23, { "PUSH23", 23, 0, 1, false } },
+ { Instruction::PUSH24, { "PUSH24", 24, 0, 1, false } },
+ { Instruction::PUSH25, { "PUSH25", 25, 0, 1, false } },
+ { Instruction::PUSH26, { "PUSH26", 26, 0, 1, false } },
+ { Instruction::PUSH27, { "PUSH27", 27, 0, 1, false } },
+ { Instruction::PUSH28, { "PUSH28", 28, 0, 1, false } },
+ { Instruction::PUSH29, { "PUSH29", 29, 0, 1, false } },
+ { Instruction::PUSH30, { "PUSH30", 30, 0, 1, false } },
+ { Instruction::PUSH31, { "PUSH31", 31, 0, 1, false } },
+ { Instruction::PUSH32, { "PUSH32", 32, 0, 1, false } },
+ { Instruction::DUP1, { "DUP1", 0, 1, 2, false } },
+ { Instruction::DUP2, { "DUP2", 0, 2, 3, false } },
+ { Instruction::DUP3, { "DUP3", 0, 3, 4, false } },
+ { Instruction::DUP4, { "DUP4", 0, 4, 5, false } },
+ { Instruction::DUP5, { "DUP5", 0, 5, 6, false } },
+ { Instruction::DUP6, { "DUP6", 0, 6, 7, false } },
+ { Instruction::DUP7, { "DUP7", 0, 7, 8, false } },
+ { Instruction::DUP8, { "DUP8", 0, 8, 9, false } },
+ { Instruction::DUP9, { "DUP9", 0, 9, 10, false } },
+ { Instruction::DUP10, { "DUP10", 0, 10, 11, false } },
+ { Instruction::DUP11, { "DUP11", 0, 11, 12, false } },
+ { Instruction::DUP12, { "DUP12", 0, 12, 13, false } },
+ { Instruction::DUP13, { "DUP13", 0, 13, 14, false } },
+ { Instruction::DUP14, { "DUP14", 0, 14, 15, false } },
+ { Instruction::DUP15, { "DUP15", 0, 15, 16, false } },
+ { Instruction::DUP16, { "DUP16", 0, 16, 17, false } },
+ { Instruction::SWAP1, { "SWAP1", 0, 2, 2, false } },
+ { Instruction::SWAP2, { "SWAP2", 0, 3, 3, false } },
+ { Instruction::SWAP3, { "SWAP3", 0, 4, 4, false } },
+ { Instruction::SWAP4, { "SWAP4", 0, 5, 5, false } },
+ { Instruction::SWAP5, { "SWAP5", 0, 6, 6, false } },
+ { Instruction::SWAP6, { "SWAP6", 0, 7, 7, false } },
+ { Instruction::SWAP7, { "SWAP7", 0, 8, 8, false } },
+ { Instruction::SWAP8, { "SWAP8", 0, 9, 9, false } },
+ { Instruction::SWAP9, { "SWAP9", 0, 10, 10, false } },
+ { Instruction::SWAP10, { "SWAP10", 0, 11, 11, false } },
+ { Instruction::SWAP11, { "SWAP11", 0, 12, 12, false } },
+ { Instruction::SWAP12, { "SWAP12", 0, 13, 13, false } },
+ { Instruction::SWAP13, { "SWAP13", 0, 14, 14, false } },
+ { Instruction::SWAP14, { "SWAP14", 0, 15, 15, false } },
+ { Instruction::SWAP15, { "SWAP15", 0, 16, 16, false } },
+ { Instruction::SWAP16, { "SWAP16", 0, 17, 17, false } },
+ { Instruction::LOG0, { "LOG0", 0, 2, 0, true } },
+ { Instruction::LOG1, { "LOG1", 0, 3, 0, true } },
+ { Instruction::LOG2, { "LOG2", 0, 4, 0, true } },
+ { Instruction::LOG3, { "LOG3", 0, 5, 0, true } },
+ { Instruction::LOG4, { "LOG4", 0, 6, 0, true } },
+ { Instruction::CREATE, { "CREATE", 0, 3, 1, true } },
+ { Instruction::CALL, { "CALL", 0, 7, 1, true } },
+ { Instruction::CALLCODE, { "CALLCODE", 0, 7, 1, true } },
+ { Instruction::RETURN, { "RETURN", 0, 2, 0, true } },
+ { Instruction::SUICIDE, { "SUICIDE", 0, 1, 0, true } }
+};
+
+string dev::eth::disassemble(bytes const& _mem)
+{
+ stringstream ret;
+ unsigned numerics = 0;
+ for (auto it = _mem.begin(); it != _mem.end(); ++it)
+ {
+ byte n = *it;
+ auto iit = c_instructionInfo.find((Instruction)n);
+ if (numerics || iit == c_instructionInfo.end() || (byte)iit->first != n) // not an instruction or expecting an argument...
+ {
+ if (numerics)
+ numerics--;
+ ret << "0x" << hex << (int)n << " ";
+ }
+ else
+ {
+ auto const& ii = iit->second;
+ ret << ii.name << " ";
+ numerics = ii.additional;
+ }
+ }
+ return ret.str();
+}
+
+InstructionInfo dev::eth::instructionInfo(Instruction _inst)
+{
+ try
+ {
+ return c_instructionInfo.at(_inst);
+ }
+ catch (...)
+ {
+ cwarn << "\n" << boost::current_exception_diagnostic_information();
+ return InstructionInfo({"", 0, 0, 0, false});
+ }
+}
+
+bool dev::eth::isValidInstruction(Instruction _inst)
+{
+ return !!c_instructionInfo.count(_inst);
+}
diff --git a/libevmface/Instruction.h b/libevmcore/Instruction.h
similarity index 98%
rename from libevmface/Instruction.h
rename to libevmcore/Instruction.h
index fadb5ab14..eb85c0610 100644
--- a/libevmface/Instruction.h
+++ b/libevmcore/Instruction.h
@@ -22,18 +22,13 @@
#pragma once
#include
-#include
-
-namespace boost { namespace spirit { class utree; } }
-namespace sp = boost::spirit;
+#include
namespace dev
{
namespace eth
{
-struct InvalidOpcode: virtual Exception {};
-
/// Virtual machine bytecode instruction.
enum class Instruction: uint8_t
{
@@ -209,6 +204,7 @@ struct InstructionInfo
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
};
/// Information on all the instructions.
diff --git a/libevmface/Instruction.cpp b/libevmface/Instruction.cpp
deleted file mode 100644
index a55cc2242..000000000
--- a/libevmface/Instruction.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- 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 .
-*/
-/** @file Instruction.cpp
- * @author Gav Wood
- * @date 2014
- */
-
-#include "Instruction.h"
-
-#include
-#include
-#include
-using namespace std;
-using namespace dev;
-using namespace dev::eth;
-
-const std::map dev::eth::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 },
- { "PREVHASH", Instruction::PREVHASH },
- { "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 },
- { "SUICIDE", Instruction::SUICIDE }
-};
-
-static const std::map c_instructionInfo =
-{ // Add, Args, Ret
- { Instruction::STOP, { "STOP", 0, 0, 0 } },
- { Instruction::ADD, { "ADD", 0, 2, 1 } },
- { Instruction::SUB, { "SUB", 0, 2, 1 } },
- { Instruction::MUL, { "MUL", 0, 2, 1 } },
- { Instruction::DIV, { "DIV", 0, 2, 1 } },
- { Instruction::SDIV, { "SDIV", 0, 2, 1 } },
- { Instruction::MOD, { "MOD", 0, 2, 1 } },
- { Instruction::SMOD, { "SMOD", 0, 2, 1 } },
- { Instruction::EXP, { "EXP", 0, 2, 1 } },
- { Instruction::NOT, { "BNOT", 0, 1, 1 } },
- { Instruction::LT, { "LT", 0, 2, 1 } },
- { Instruction::GT, { "GT", 0, 2, 1 } },
- { Instruction::SLT, { "SLT", 0, 2, 1 } },
- { Instruction::SGT, { "SGT", 0, 2, 1 } },
- { Instruction::EQ, { "EQ", 0, 2, 1 } },
- { Instruction::ISZERO, { "NOT", 0, 1, 1 } },
- { Instruction::AND, { "AND", 0, 2, 1 } },
- { Instruction::OR, { "OR", 0, 2, 1 } },
- { Instruction::XOR, { "XOR", 0, 2, 1 } },
- { Instruction::BYTE, { "BYTE", 0, 2, 1 } },
- { Instruction::ADDMOD, { "ADDMOD", 0, 3, 1 } },
- { Instruction::MULMOD, { "MULMOD", 0, 3, 1 } },
- { Instruction::SIGNEXTEND, { "SIGNEXTEND", 0, 2, 1 } },
- { Instruction::SHA3, { "SHA3", 0, 2, 1 } },
- { Instruction::ADDRESS, { "ADDRESS", 0, 0, 1 } },
- { Instruction::BALANCE, { "BALANCE", 0, 1, 1 } },
- { Instruction::ORIGIN, { "ORIGIN", 0, 0, 1 } },
- { Instruction::CALLER, { "CALLER", 0, 0, 1 } },
- { Instruction::CALLVALUE, { "CALLVALUE", 0, 0, 1 } },
- { Instruction::CALLDATALOAD,{ "CALLDATALOAD", 0, 1, 1 } },
- { Instruction::CALLDATASIZE,{ "CALLDATASIZE", 0, 0, 1 } },
- { Instruction::CALLDATACOPY,{ "CALLDATACOPY", 0, 3, 0 } },
- { Instruction::CODESIZE, { "CODESIZE", 0, 0, 1 } },
- { Instruction::CODECOPY, { "CODECOPY", 0, 3, 0 } },
- { Instruction::GASPRICE, { "GASPRICE", 0, 0, 1 } },
- { Instruction::EXTCODESIZE, { "EXTCODESIZE", 0, 1, 1 } },
- { Instruction::EXTCODECOPY, { "EXTCODECOPY", 0, 4, 0 } },
- { Instruction::PREVHASH, { "PREVHASH", 0, 0, 1 } },
- { Instruction::COINBASE, { "COINBASE", 0, 0, 1 } },
- { Instruction::TIMESTAMP, { "TIMESTAMP", 0, 0, 1 } },
- { Instruction::NUMBER, { "NUMBER", 0, 0, 1 } },
- { Instruction::DIFFICULTY, { "DIFFICULTY", 0, 0, 1 } },
- { Instruction::GASLIMIT, { "GASLIMIT", 0, 0, 1 } },
- { Instruction::POP, { "POP", 0, 1, 0 } },
- { Instruction::MLOAD, { "MLOAD", 0, 1, 1 } },
- { Instruction::MSTORE, { "MSTORE", 0, 2, 0 } },
- { Instruction::MSTORE8, { "MSTORE8", 0, 2, 0 } },
- { Instruction::SLOAD, { "SLOAD", 0, 1, 1 } },
- { Instruction::SSTORE, { "SSTORE", 0, 2, 0 } },
- { Instruction::JUMP, { "JUMP", 0, 1, 0 } },
- { Instruction::JUMPI, { "JUMPI", 0, 2, 0 } },
- { Instruction::PC, { "PC", 0, 0, 1 } },
- { Instruction::MSIZE, { "MSIZE", 0, 0, 1 } },
- { Instruction::GAS, { "GAS", 0, 0, 1 } },
- { Instruction::JUMPDEST, { "JUMPDEST", 0, 1, 0 } },
- { Instruction::PUSH1, { "PUSH1", 1, 0, 1 } },
- { Instruction::PUSH2, { "PUSH2", 2, 0, 1 } },
- { Instruction::PUSH3, { "PUSH3", 3, 0, 1 } },
- { Instruction::PUSH4, { "PUSH4", 4, 0, 1 } },
- { Instruction::PUSH5, { "PUSH5", 5, 0, 1 } },
- { Instruction::PUSH6, { "PUSH6", 6, 0, 1 } },
- { Instruction::PUSH7, { "PUSH7", 7, 0, 1 } },
- { Instruction::PUSH8, { "PUSH8", 8, 0, 1 } },
- { Instruction::PUSH9, { "PUSH9", 9, 0, 1 } },
- { Instruction::PUSH10, { "PUSH10", 10, 0, 1 } },
- { Instruction::PUSH11, { "PUSH11", 11, 0, 1 } },
- { Instruction::PUSH12, { "PUSH12", 12, 0, 1 } },
- { Instruction::PUSH13, { "PUSH13", 13, 0, 1 } },
- { Instruction::PUSH14, { "PUSH14", 14, 0, 1 } },
- { Instruction::PUSH15, { "PUSH15", 15, 0, 1 } },
- { Instruction::PUSH16, { "PUSH16", 16, 0, 1 } },
- { Instruction::PUSH17, { "PUSH17", 17, 0, 1 } },
- { Instruction::PUSH18, { "PUSH18", 18, 0, 1 } },
- { Instruction::PUSH19, { "PUSH19", 19, 0, 1 } },
- { Instruction::PUSH20, { "PUSH20", 20, 0, 1 } },
- { Instruction::PUSH21, { "PUSH21", 21, 0, 1 } },
- { Instruction::PUSH22, { "PUSH22", 22, 0, 1 } },
- { Instruction::PUSH23, { "PUSH23", 23, 0, 1 } },
- { Instruction::PUSH24, { "PUSH24", 24, 0, 1 } },
- { Instruction::PUSH25, { "PUSH25", 25, 0, 1 } },
- { Instruction::PUSH26, { "PUSH26", 26, 0, 1 } },
- { Instruction::PUSH27, { "PUSH27", 27, 0, 1 } },
- { Instruction::PUSH28, { "PUSH28", 28, 0, 1 } },
- { Instruction::PUSH29, { "PUSH29", 29, 0, 1 } },
- { Instruction::PUSH30, { "PUSH30", 30, 0, 1 } },
- { Instruction::PUSH31, { "PUSH31", 31, 0, 1 } },
- { Instruction::PUSH32, { "PUSH32", 32, 0, 1 } },
- { Instruction::DUP1, { "DUP1", 0, 1, 2 } },
- { Instruction::DUP2, { "DUP2", 0, 2, 3 } },
- { Instruction::DUP3, { "DUP3", 0, 3, 4 } },
- { Instruction::DUP4, { "DUP4", 0, 4, 5 } },
- { Instruction::DUP5, { "DUP5", 0, 5, 6 } },
- { Instruction::DUP6, { "DUP6", 0, 6, 7 } },
- { Instruction::DUP7, { "DUP7", 0, 7, 8 } },
- { Instruction::DUP8, { "DUP8", 0, 8, 9 } },
- { Instruction::DUP9, { "DUP9", 0, 9, 10 } },
- { Instruction::DUP10, { "DUP10", 0, 10, 11 } },
- { Instruction::DUP11, { "DUP11", 0, 11, 12 } },
- { Instruction::DUP12, { "DUP12", 0, 12, 13 } },
- { Instruction::DUP13, { "DUP13", 0, 13, 14 } },
- { Instruction::DUP14, { "DUP14", 0, 14, 15 } },
- { Instruction::DUP15, { "DUP15", 0, 15, 16 } },
- { Instruction::DUP16, { "DUP16", 0, 16, 17 } },
- { Instruction::SWAP1, { "SWAP1", 0, 2, 2 } },
- { Instruction::SWAP2, { "SWAP2", 0, 3, 3 } },
- { Instruction::SWAP3, { "SWAP3", 0, 4, 4 } },
- { Instruction::SWAP4, { "SWAP4", 0, 5, 5 } },
- { Instruction::SWAP5, { "SWAP5", 0, 6, 6 } },
- { Instruction::SWAP6, { "SWAP6", 0, 7, 7 } },
- { Instruction::SWAP7, { "SWAP7", 0, 8, 8 } },
- { Instruction::SWAP8, { "SWAP8", 0, 9, 9 } },
- { Instruction::SWAP9, { "SWAP9", 0, 10, 10 } },
- { Instruction::SWAP10, { "SWAP10", 0, 11, 11 } },
- { Instruction::SWAP11, { "SWAP11", 0, 12, 12 } },
- { Instruction::SWAP12, { "SWAP12", 0, 13, 13 } },
- { Instruction::SWAP13, { "SWAP13", 0, 14, 14 } },
- { Instruction::SWAP14, { "SWAP14", 0, 15, 15 } },
- { Instruction::SWAP15, { "SWAP15", 0, 16, 16 } },
- { Instruction::SWAP16, { "SWAP16", 0, 17, 17 } },
- { Instruction::LOG0, { "LOG0", 0, 1, 0 } },
- { Instruction::LOG1, { "LOG1", 0, 2, 0 } },
- { Instruction::LOG2, { "LOG2", 0, 3, 0 } },
- { Instruction::LOG3, { "LOG3", 0, 4, 0 } },
- { Instruction::LOG4, { "LOG4", 0, 5, 0 } },
- { Instruction::CREATE, { "CREATE", 0, 3, 1 } },
- { Instruction::CALL, { "CALL", 0, 7, 1 } },
- { Instruction::CALLCODE, { "CALLCODE", 0, 7, 1 } },
- { Instruction::RETURN, { "RETURN", 0, 2, 0 } },
- { Instruction::SUICIDE, { "SUICIDE", 0, 1, 0} }
-};
-
-string dev::eth::disassemble(bytes const& _mem)
-{
- stringstream ret;
- unsigned numerics = 0;
- for (auto it = _mem.begin(); it != _mem.end(); ++it)
- {
- byte n = *it;
- auto iit = c_instructionInfo.find((Instruction)n);
- if (numerics || iit == c_instructionInfo.end() || (byte)iit->first != n) // not an instruction or expecting an argument...
- {
- if (numerics)
- numerics--;
- ret << "0x" << hex << (int)n << " ";
- }
- else
- {
- auto const& ii = iit->second;
- ret << ii.name << " ";
- numerics = ii.additional;
- }
- }
- return ret.str();
-}
-
-InstructionInfo dev::eth::instructionInfo(Instruction _inst)
-{
- try
- {
- return c_instructionInfo.at(_inst);
- }
- catch (...)
- {
- cwarn << "\n" << boost::current_exception_diagnostic_information();
- return InstructionInfo({"", 0, 0, 0});
- }
-}
-
-bool dev::eth::isValidInstruction(Instruction _inst)
-{
- return !!c_instructionInfo.count(_inst);
-}
diff --git a/libevmjit/CMakeLists.txt b/libevmjit/CMakeLists.txt
index cc63e72db..b06316dd2 100644
--- a/libevmjit/CMakeLists.txt
+++ b/libevmjit/CMakeLists.txt
@@ -18,7 +18,7 @@ include_directories(..)
target_link_libraries(${EXECUTABLE} devcore)
target_link_libraries(${EXECUTABLE} ethcore)
target_link_libraries(${EXECUTABLE} evm)
-target_link_libraries(${EXECUTABLE} evmface)
+target_link_libraries(${EXECUTABLE} evmcore)
if ("${TARGET_PLATFORM}" STREQUAL "w64")
diff --git a/libevmjit/Compiler.cpp b/libevmjit/Compiler.cpp
index 295f3a131..94e1450cd 100644
--- a/libevmjit/Compiler.cpp
+++ b/libevmjit/Compiler.cpp
@@ -13,7 +13,7 @@
#include
#include
-#include
+#include
#include "Type.h"
#include "Memory.h"
@@ -39,7 +39,7 @@ Compiler::Compiler(Options const& _options):
Type::init(m_builder.getContext());
}
-void Compiler::createBasicBlocks(bytesConstRef _bytecode)
+void Compiler::createBasicBlocks(bytes const& _bytecode)
{
std::set splitPoints; // Sorted collections of instruction indices where basic blocks start/end
@@ -151,7 +151,7 @@ void Compiler::createBasicBlocks(bytesConstRef _bytecode)
m_indirectJumpTargets.push_back(&basicBlocks.find(*it)->second);
}
-std::unique_ptr Compiler::compile(bytesConstRef _bytecode)
+std::unique_ptr Compiler::compile(bytes const& _bytecode)
{
auto module = std::unique_ptr(new llvm::Module("main", m_builder.getContext()));
@@ -247,7 +247,7 @@ std::unique_ptr Compiler::compile(bytesConstRef _bytecode)
}
-void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytesConstRef _bytecode, RuntimeManager& _runtimeManager,
+void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode, RuntimeManager& _runtimeManager,
Arith256& _arith, Memory& _memory, Ext& _ext, GasMeter& _gasMeter, llvm::BasicBlock* _nextBasicBlock)
{
if (!_nextBasicBlock) // this is the last block in the code
@@ -508,7 +508,11 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytesConstRef _bytecod
case Instruction::POP:
{
- stack.pop();
+ auto val = stack.pop();
+ static_cast(val);
+ // Generate a dummy use of val to make sure that a get(0) will be emitted at this point,
+ // so that StackTooSmall will be thrown
+ // m_builder.CreateICmpEQ(val, val, "dummy");
break;
}
@@ -791,6 +795,25 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytesConstRef _bytecod
break;
}
+ case Instruction::LOG0:
+ case Instruction::LOG1:
+ case Instruction::LOG2:
+ case Instruction::LOG3:
+ case Instruction::LOG4:
+ {
+ auto beginIdx = stack.pop();
+ auto numBytes = stack.pop();
+ _memory.require(beginIdx, numBytes);
+
+ std::array topics;
+ auto numTopics = static_cast(inst) - static_cast(Instruction::LOG0);
+ for (size_t i = 0; i < numTopics; ++i)
+ topics[i] = stack.pop();
+
+ _ext.log(beginIdx, numBytes, numTopics, topics);
+ break;
+ }
+
default: // Invalid instruction - runtime exception
{
_runtimeManager.raiseException(ReturnCode::BadInstruction);
diff --git a/libevmjit/Compiler.h b/libevmjit/Compiler.h
index 12b7f6e0e..a618f41a3 100644
--- a/libevmjit/Compiler.h
+++ b/libevmjit/Compiler.h
@@ -40,13 +40,13 @@ public:
Compiler(Options const& _options);
- std::unique_ptr compile(bytesConstRef _bytecode);
+ std::unique_ptr compile(bytes const& _bytecode);
private:
- void createBasicBlocks(bytesConstRef _bytecode);
+ void createBasicBlocks(bytes const& _bytecode);
- void compileBasicBlock(BasicBlock& _basicBlock, bytesConstRef _bytecode, class RuntimeManager& _runtimeManager, class Arith256& _arith, class Memory& _memory, class Ext& _ext, class GasMeter& _gasMeter, llvm::BasicBlock* _nextBasicBlock);
+ void compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode, class RuntimeManager& _runtimeManager, class Arith256& _arith, class Memory& _memory, class Ext& _ext, class GasMeter& _gasMeter, llvm::BasicBlock* _nextBasicBlock);
void removeDeadBlocks();
diff --git a/libevmjit/ExecutionEngine.cpp b/libevmjit/ExecutionEngine.cpp
index 4c617d9ea..02b12d373 100644
--- a/libevmjit/ExecutionEngine.cpp
+++ b/libevmjit/ExecutionEngine.cpp
@@ -37,10 +37,9 @@ namespace jit
ExecutionEngine::ExecutionEngine()
{
-
}
-int ExecutionEngine::run(std::unique_ptr _module, u256& _gas, ExtVMFace* _ext)
+int ExecutionEngine::run(std::unique_ptr _module, u256& _gas, bool _outputLogs, ExtVMFace& _ext)
{
auto module = _module.get(); // Keep ownership of the module in _module
@@ -83,34 +82,13 @@ int ExecutionEngine::run(std::unique_ptr _module, u256& _gas, ExtV
clog(JIT) << "Module finalization time: "
<< std::chrono::duration_cast(finalizationEndTime - finalizationStartTime).count();
- // Create fake ExtVM interface
- if (!_ext)
- {
- _ext = new ExtVMFace;
- _ext->myAddress = Address(1122334455667788);
- _ext->caller = Address(0xfacefacefaceface);
- _ext->origin = Address(101010101010101010);
- _ext->value = 0xabcd;
- _ext->gasPrice = 1002;
- _ext->previousBlock.hash = u256(1003);
- _ext->currentBlock.coinbaseAddress = Address(1004);
- _ext->currentBlock.timestamp = 1005;
- _ext->currentBlock.number = 1006;
- _ext->currentBlock.difficulty = 1007;
- _ext->currentBlock.gasLimit = 1008;
- std::string calldata = "Hello the Beautiful World of Ethereum!";
- _ext->data = calldata;
- unsigned char fakecode[] = {0x0d, 0x0e, 0x0a, 0x0d, 0x0b, 0x0e, 0xe, 0xf};
- _ext->code = decltype(_ext->code)(fakecode, 8);
- }
-
auto entryFunc = module->getFunction("main");
if (!entryFunc)
BOOST_THROW_EXCEPTION(Exception() << errinfo_comment("main function not found"));
ReturnCode returnCode;
std::jmp_buf buf;
- Runtime runtime(_gas, *_ext, buf);
+ Runtime runtime(_gas, _ext, buf, _outputLogs);
auto r = setjmp(buf);
if (r == 0)
{
diff --git a/libevmjit/ExecutionEngine.h b/libevmjit/ExecutionEngine.h
index 15a4e6ef7..8cf1ec746 100644
--- a/libevmjit/ExecutionEngine.h
+++ b/libevmjit/ExecutionEngine.h
@@ -18,7 +18,7 @@ class ExecutionEngine
public:
ExecutionEngine();
- int run(std::unique_ptr module, u256& _gas, ExtVMFace* _ext = nullptr);
+ int run(std::unique_ptr module, u256& _gas, bool _outputLogs, ExtVMFace& _ext);
bytes returnData;
};
diff --git a/libevmjit/Ext.cpp b/libevmjit/Ext.cpp
index f39ab5755..17cbf5dc4 100644
--- a/libevmjit/Ext.cpp
+++ b/libevmjit/Ext.cpp
@@ -59,6 +59,11 @@ Ext::Ext(RuntimeManager& _runtimeManager):
m_exp = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 4}, false), Linkage::ExternalLinkage, "ext_exp", module);
m_codeAt = llvm::Function::Create(llvm::FunctionType::get(Type::BytePtr, {argsTypes, 2}, false), Linkage::ExternalLinkage, "ext_codeAt", module);
m_codesizeAt = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 3}, false), Linkage::ExternalLinkage, "ext_codesizeAt", module);
+ m_log0 = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 3}, false), Linkage::ExternalLinkage, "ext_log0", module);
+ m_log1 = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 4}, false), Linkage::ExternalLinkage, "ext_log1", module);
+ m_log2 = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 5}, false), Linkage::ExternalLinkage, "ext_log2", module);
+ m_log3 = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 6}, false), Linkage::ExternalLinkage, "ext_log3", module);
+ m_log4 = llvm::Function::Create(llvm::FunctionType::get(Type::Void, {argsTypes, 7}, false), Linkage::ExternalLinkage, "ext_log4", module);
}
llvm::Value* Ext::store(llvm::Value* _index)
@@ -160,6 +165,21 @@ llvm::Value* Ext::codesizeAt(llvm::Value* _addr)
return m_builder.CreateLoad(m_args[1]);
}
+void Ext::log(llvm::Value* _memIdx, llvm::Value* _numBytes, size_t _numTopics, std::array const& _topics)
+{
+ static llvm::Value* args[] = {nullptr, m_args[0], m_args[1], m_arg2, m_arg3, m_arg4, m_arg5};
+ static llvm::Value* funcs[] = {m_log0, m_log1, m_log2, m_log3, m_log4};
+
+ args[0] = getRuntimeManager().getRuntimePtr();
+ m_builder.CreateStore(_memIdx, m_args[0]);
+ m_builder.CreateStore(_numBytes, m_args[1]);
+
+ for (size_t i = 0; i < _numTopics; ++i)
+ m_builder.CreateStore(_topics[i], args[i + 3]);
+
+ m_builder.CreateCall(funcs[_numTopics], llvm::ArrayRef(args, _numTopics + 3));
+}
+
}
@@ -289,6 +309,111 @@ extern "C"
*o_ret = eth2llvm(u256(code.size()));
}
+ void ext_show_bytes(bytesConstRef _bytes)
+ {
+ for (auto b : _bytes)
+ std::cerr << std::hex << std::setw(2) << std::setfill('0') << static_cast(b) << " ";
+ std::cerr << std::endl;
+ }
+
+ EXPORT void ext_log0(Runtime* _rt, i256* _memIdx, i256* _numBytes)
+ {
+ auto&& ext = _rt->getExt();
+
+ auto memIdx = static_cast(llvm2eth(*_memIdx));
+ auto numBytes = static_cast(llvm2eth(*_numBytes));
+
+ auto dataRef = bytesConstRef(_rt->getMemory().data() + memIdx, numBytes);
+ ext.log({}, dataRef);
+
+ if (_rt->outputLogs())
+ {
+ std::cerr << "LOG: ";
+ ext_show_bytes(dataRef);
+ }
+ }
+
+ EXPORT void ext_log1(Runtime* _rt, i256* _memIdx, i256* _numBytes, i256* _topic1)
+ {
+ auto&& ext = _rt->getExt();
+
+ auto memIdx = static_cast(llvm2eth(*_memIdx));
+ auto numBytes = static_cast(llvm2eth(*_numBytes));
+
+ auto topic1 = llvm2eth(*_topic1);
+
+ auto dataRef = bytesConstRef(_rt->getMemory().data() + memIdx, numBytes);
+ ext.log({topic1}, dataRef);
+
+ if (_rt->outputLogs())
+ {
+ std::cerr << "LOG [" << topic1 << "]: ";
+ ext_show_bytes(dataRef);
+ }
+ }
+
+ EXPORT void ext_log2(Runtime* _rt, i256* _memIdx, i256* _numBytes, i256* _topic1, i256* _topic2)
+ {
+ auto&& ext = _rt->getExt();
+
+ auto memIdx = static_cast(llvm2eth(*_memIdx));
+ auto numBytes = static_cast(llvm2eth(*_numBytes));
+
+ auto topic1 = llvm2eth(*_topic1);
+ auto topic2 = llvm2eth(*_topic2);
+
+ auto dataRef = bytesConstRef(_rt->getMemory().data() + memIdx, numBytes);
+ ext.log({topic1, topic2}, dataRef);
+
+ if (_rt->outputLogs())
+ {
+ std::cerr << "LOG [" << topic1 << "][" << topic2 << "]: ";
+ ext_show_bytes(dataRef);
+ }
+ }
+
+ EXPORT void ext_log3(Runtime* _rt, i256* _memIdx, i256* _numBytes, i256* _topic1, i256* _topic2, i256* _topic3)
+ {
+ auto&& ext = _rt->getExt();
+
+ auto memIdx = static_cast(llvm2eth(*_memIdx));
+ auto numBytes = static_cast(llvm2eth(*_numBytes));
+
+ auto topic1 = llvm2eth(*_topic1);
+ auto topic2 = llvm2eth(*_topic2);
+ auto topic3 = llvm2eth(*_topic3);
+
+ auto dataRef = bytesConstRef(_rt->getMemory().data() + memIdx, numBytes);
+ ext.log({topic1, topic2, topic3}, dataRef);
+
+ if (_rt->outputLogs())
+ {
+ std::cerr << "LOG [" << topic1 << "][" << topic2 << "][" << topic3 << "]: ";
+ ext_show_bytes(dataRef);
+ }
+ }
+
+ EXPORT void ext_log4(Runtime* _rt, i256* _memIdx, i256* _numBytes, i256* _topic1, i256* _topic2, i256* _topic3, i256* _topic4)
+ {
+ auto&& ext = _rt->getExt();
+
+ auto memIdx = static_cast(llvm2eth(*_memIdx));
+ auto numBytes = static_cast(llvm2eth(*_numBytes));
+
+ auto topic1 = llvm2eth(*_topic1);
+ auto topic2 = llvm2eth(*_topic2);
+ auto topic3 = llvm2eth(*_topic3);
+ auto topic4 = llvm2eth(*_topic4);
+
+ auto dataRef = bytesConstRef(_rt->getMemory().data() + memIdx, numBytes);
+ ext.log({topic1, topic2, topic3, topic4}, dataRef);
+
+ if (_rt->outputLogs())
+ {
+ std::cerr << "LOG [" << topic1 << "][" << topic2 << "][" << topic3 << "][" << topic4 << "]: ";
+ ext_show_bytes(dataRef);
+ }
+ }
}
}
}
diff --git a/libevmjit/Ext.h b/libevmjit/Ext.h
index 8e70af7d0..54380dda6 100644
--- a/libevmjit/Ext.h
+++ b/libevmjit/Ext.h
@@ -31,8 +31,10 @@ public:
llvm::Value* codeAt(llvm::Value* _addr);
llvm::Value* codesizeAt(llvm::Value* _addr);
+ void log(llvm::Value* _memIdx, llvm::Value* _numBytes, size_t _numTopics, std::array const& _topics);
private:
+
llvm::Value* m_args[2];
llvm::Value* m_arg2;
llvm::Value* m_arg3;
@@ -53,6 +55,11 @@ private:
llvm::Function* m_exp;
llvm::Function* m_codeAt;
llvm::Function* m_codesizeAt;
+ llvm::Function* m_log0;
+ llvm::Function* m_log1;
+ llvm::Function* m_log2;
+ llvm::Function* m_log3;
+ llvm::Function* m_log4;
};
diff --git a/libevmjit/GasMeter.cpp b/libevmjit/GasMeter.cpp
index 7a6a0ebd2..734931c32 100644
--- a/libevmjit/GasMeter.cpp
+++ b/libevmjit/GasMeter.cpp
@@ -5,7 +5,7 @@
#include
#include
-#include
+#include
#include
#include "Type.h"
diff --git a/libevmjit/GasMeter.h b/libevmjit/GasMeter.h
index 3de227651..4be6c1a02 100644
--- a/libevmjit/GasMeter.h
+++ b/libevmjit/GasMeter.h
@@ -1,7 +1,7 @@
#pragma once
-#include
+#include
#include "CompilerHelper.h"
diff --git a/libevmjit/Memory.cpp b/libevmjit/Memory.cpp
index 89cef4d48..53cccf92b 100644
--- a/libevmjit/Memory.cpp
+++ b/libevmjit/Memory.cpp
@@ -147,24 +147,18 @@ llvm::Function* Memory::createFunc(bool _isStore, llvm::Type* _valueType, GasMet
llvm::Value* Memory::loadWord(llvm::Value* _addr)
{
auto value = m_builder.CreateCall(m_loadWord, _addr);
-
- dump(0);
return value;
}
void Memory::storeWord(llvm::Value* _addr, llvm::Value* _word)
{
m_builder.CreateCall2(m_storeWord, _addr, _word);
-
- dump(0);
}
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _word)
{
auto byte = m_builder.CreateTrunc(_word, Type::Byte, "byte");
m_builder.CreateCall2(m_storeByte, _addr, byte);
-
- dump(0);
}
llvm::Value* Memory::getData()
@@ -205,18 +199,6 @@ void Memory::copyBytes(llvm::Value* _srcPtr, llvm::Value* _srcSize, llvm::Value*
m_builder.CreateMemCpy(destPtr, srcPtr, bytesToCopy, 0);
}
-void Memory::dump(uint64_t _begin, uint64_t _end)
-{
- if (getenv("EVMCC_DEBUG_MEMORY") == nullptr)
- return;
-
- auto beginVal = llvm::ConstantInt::get(m_builder.getInt64Ty(), _begin);
- auto endVal = llvm::ConstantInt::get(m_builder.getInt64Ty(), _end);
-
- std::vector args = {beginVal, endVal};
- m_builder.CreateCall(m_memDump, llvm::ArrayRef(args));
-}
-
}
}
}
diff --git a/libevmjit/Memory.h b/libevmjit/Memory.h
index 37bfb15f5..c6ba02a54 100644
--- a/libevmjit/Memory.h
+++ b/libevmjit/Memory.h
@@ -27,8 +27,6 @@ public:
/// Requires the amount of memory to for data defined by offset and size. And counts gas fee for that memory.
void require(llvm::Value* _offset, llvm::Value* _size);
- void dump(uint64_t _begin, uint64_t _end = 0);
-
private:
llvm::Function* createFunc(bool _isStore, llvm::Type* _type, GasMeter& _gasMeter);
llvm::Function* createRequireFunc(GasMeter& _gasMeter, RuntimeManager& _runtimeManager);
diff --git a/libevmjit/Runtime.cpp b/libevmjit/Runtime.cpp
index 982dd9f36..8e52b648a 100644
--- a/libevmjit/Runtime.cpp
+++ b/libevmjit/Runtime.cpp
@@ -58,8 +58,9 @@ llvm::Twine getName(RuntimeData::Index _index)
}
}
-Runtime::Runtime(u256 _gas, ExtVMFace& _ext, jmp_buf _jmpBuf):
- m_ext(_ext)
+Runtime::Runtime(u256 _gas, ExtVMFace& _ext, jmp_buf _jmpBuf, bool _outputLogs):
+ m_ext(_ext),
+ m_outputLogs(_outputLogs)
{
set(RuntimeData::Gas, _gas);
set(RuntimeData::Address, fromAddress(_ext.myAddress));
@@ -101,6 +102,11 @@ bytesConstRef Runtime::getReturnData() const
return {m_memory.data() + offset, size};
}
+bool Runtime::outputLogs() const
+{
+ return m_outputLogs;
+}
+
RuntimeManager::RuntimeManager(llvm::IRBuilder<>& _builder): CompilerHelper(_builder)
{
diff --git a/libevmjit/Runtime.h b/libevmjit/Runtime.h
index 8c784b394..8f485794a 100644
--- a/libevmjit/Runtime.h
+++ b/libevmjit/Runtime.h
@@ -63,7 +63,7 @@ using MemoryImpl = bytes;
class Runtime
{
public:
- Runtime(u256 _gas, ExtVMFace& _ext, jmp_buf _jmpBuf);
+ Runtime(u256 _gas, ExtVMFace& _ext, jmp_buf _jmpBuf, bool _outputLogs);
Runtime(const Runtime&) = delete;
void operator=(const Runtime&) = delete;
@@ -77,6 +77,7 @@ public:
u256 getGas() const;
bytesConstRef getReturnData() const;
decltype(&jmp_buf{}[0]) getJmpBuf() { return m_data.jmpBuf; }
+ bool outputLogs() const;
private:
void set(RuntimeData::Index _index, u256 _value);
@@ -86,6 +87,7 @@ private:
StackImpl m_stack;
MemoryImpl m_memory;
ExtVMFace& m_ext;
+ bool m_outputLogs; ///< write LOG statements to console
};
class RuntimeManager: public CompilerHelper
diff --git a/libevmjit/Utils.cpp b/libevmjit/Utils.cpp
index 966dc69bd..548ee0e1f 100644
--- a/libevmjit/Utils.cpp
+++ b/libevmjit/Utils.cpp
@@ -35,7 +35,7 @@ i256 eth2llvm(u256 _u)
return i;
}
-u256 readPushData(const byte*& _curr, const byte* _end)
+u256 readPushData(bytes::const_iterator& _curr, bytes::const_iterator _end)
{
auto pushInst = *_curr;
assert(Instruction(pushInst) >= Instruction::PUSH1 && Instruction(pushInst) <= Instruction::PUSH32);
diff --git a/libevmjit/Utils.h b/libevmjit/Utils.h
index 9fa9f050e..54291f3e0 100644
--- a/libevmjit/Utils.h
+++ b/libevmjit/Utils.h
@@ -5,7 +5,7 @@
#include
#include
-#include
+#include
namespace dev
{
@@ -33,7 +33,7 @@ i256 eth2llvm(u256);
/// Reads PUSH data from pointed fragment of bytecode and constructs number out of it
/// Reading out of bytecode means reading 0
/// @param _curr is updates and points the last real byte read
-u256 readPushData(const byte*& _curr, const byte* _end);
+u256 readPushData(bytes::const_iterator& _curr, bytes::const_iterator _end);
#define ANY_PUSH PUSH1: \
case Instruction::PUSH2: \
diff --git a/libevmjit/VM.cpp b/libevmjit/VM.cpp
index 0c89587e9..9b60fccf1 100644
--- a/libevmjit/VM.cpp
+++ b/libevmjit/VM.cpp
@@ -20,7 +20,7 @@ bytesConstRef VM::go(ExtVMFace& _ext, OnOpFunc const&, uint64_t)
auto module = Compiler(defaultOptions).compile(_ext.code);
ExecutionEngine engine;
- auto exitCode = engine.run(std::move(module), m_gas, &_ext);
+ auto exitCode = engine.run(std::move(module), m_gas, false, _ext);
switch (static_cast(exitCode))
{
diff --git a/libjsqrc/main.js b/libjsqrc/main.js
index 821de6382..09fe00105 100644
--- a/libjsqrc/main.js
+++ b/libjsqrc/main.js
@@ -2,19 +2,19 @@
This file is part of ethereum.js.
ethereum.js is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
ethereum.js 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.
+ GNU Lesser General Public License for more details.
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU Lesser General Public License
along with ethereum.js. If not, see .
*/
-/** @file ethereum.js
+/** @file main.js
* @authors:
* Marek Kotewicz
* @date 2014
@@ -66,82 +66,83 @@
var ethMethods = function () {
var blockCall = function (args) {
- return typeof args[0] === "string" ? "blockByHash" : "blockByNumber";
+ return typeof args[0] === "string" ? "eth_blockByHash" : "eth_blockByNumber";
};
var transactionCall = function (args) {
- return typeof args[0] === "string" ? 'transactionByHash' : 'transactionByNumber';
+ return typeof args[0] === "string" ? 'eth_transactionByHash' : 'eth_transactionByNumber';
};
var uncleCall = function (args) {
- return typeof args[0] === "string" ? 'uncleByHash' : 'uncleByNumber';
+ return typeof args[0] === "string" ? 'eth_uncleByHash' : 'eth_uncleByNumber';
};
var methods = [
- { name: 'balanceAt', call: 'balanceAt' },
- { name: 'stateAt', call: 'stateAt' },
- { name: 'countAt', call: 'countAt'},
- { name: 'codeAt', call: 'codeAt' },
- { name: 'transact', call: 'transact' },
- { name: 'call', call: 'call' },
+ { name: 'balanceAt', call: 'eth_balanceAt' },
+ { name: 'stateAt', call: 'eth_stateAt' },
+ { name: 'countAt', call: 'eth_countAt'},
+ { name: 'codeAt', call: 'eth_codeAt' },
+ { name: 'transact', call: 'eth_transact' },
+ { name: 'call', call: 'eth_call' },
{ name: 'block', call: blockCall },
{ name: 'transaction', call: transactionCall },
{ name: 'uncle', call: uncleCall },
- { name: 'compile', call: 'compile' }
+ { name: 'compile', call: 'eth_compile' },
+ { name: 'lll', call: 'eth_lll' }
];
return methods;
};
var ethProperties = function () {
return [
- { name: 'coinbase', getter: 'coinbase', setter: 'setCoinbase' },
- { name: 'listening', getter: 'listening', setter: 'setListening' },
- { name: 'mining', getter: 'mining', setter: 'setMining' },
- { name: 'gasPrice', getter: 'gasPrice' },
- { name: 'account', getter: 'account' },
- { name: 'accounts', getter: 'accounts' },
- { name: 'peerCount', getter: 'peerCount' },
- { name: 'defaultBlock', getter: 'defaultBlock', setter: 'setDefaultBlock' },
- { name: 'number', getter: 'number'}
+ { name: 'coinbase', getter: 'eth_coinbase', setter: 'eth_setCoinbase' },
+ { name: 'listening', getter: 'eth_listening', setter: 'eth_setListening' },
+ { name: 'mining', getter: 'eth_mining', setter: 'eth_setMining' },
+ { name: 'gasPrice', getter: 'eth_gasPrice' },
+ { name: 'account', getter: 'eth_account' },
+ { name: 'accounts', getter: 'eth_accounts' },
+ { name: 'peerCount', getter: 'eth_peerCount' },
+ { name: 'defaultBlock', getter: 'eth_defaultBlock', setter: 'eth_setDefaultBlock' },
+ { name: 'number', getter: 'eth_number'}
];
};
var dbMethods = function () {
return [
- { name: 'put', call: 'put' },
- { name: 'get', call: 'get' },
- { name: 'putString', call: 'putString' },
- { name: 'getString', call: 'getString' }
+ { name: 'put', call: 'db_put' },
+ { name: 'get', call: 'db_get' },
+ { name: 'putString', call: 'db_putString' },
+ { name: 'getString', call: 'db_getString' }
];
};
var shhMethods = function () {
return [
- { name: 'post', call: 'post' },
- { name: 'newIdentity', call: 'newIdentity' },
- { name: 'haveIdentity', call: 'haveIdentity' },
- { name: 'newGroup', call: 'newGroup' },
- { name: 'addToGroup', call: 'addToGroup' }
+ { name: 'post', call: 'shh_post' },
+ { name: 'newIdentity', call: 'shh_newIdentity' },
+ { name: 'haveIdentity', call: 'shh_haveIdentity' },
+ { name: 'newGroup', call: 'shh_newGroup' },
+ { name: 'addToGroup', call: 'shh_addToGroup' }
];
};
var ethWatchMethods = function () {
var newFilter = function (args) {
- return typeof args[0] === 'string' ? 'newFilterString' : 'newFilter';
+ return typeof args[0] === 'string' ? 'eth_newFilterString' : 'eth_newFilter';
};
return [
{ name: 'newFilter', call: newFilter },
- { name: 'uninstallFilter', call: 'uninstallFilter' },
- { name: 'getMessages', call: 'getMessages' }
+ { name: 'uninstallFilter', call: 'eth_uninstallFilter' },
+ { name: 'getMessages', call: 'eth_getMessages' }
];
};
var shhWatchMethods = function () {
return [
- { name: 'newFilter', call: 'shhNewFilter' },
- { name: 'uninstallFilter', call: 'shhUninstallFilter' },
- { name: 'getMessage', call: 'shhGetMessages' }
+ { name: 'newFilter', call: 'shh_newFilter' },
+ { name: 'uninstallFilter', call: 'shh_uninstallFilter' },
+ { name: 'getMessage', call: 'shh_getMessages' }
];
};
@@ -153,15 +154,15 @@
return {call: call, args: args};
}).then(function (request) {
return new Promise(function (resolve, reject) {
- web3.provider.send(request, function (result) {
- if (result || typeof result === "boolean") {
+ web3.provider.send(request, function (err, result) {
+ if (!err) {
resolve(result);
return;
}
- reject(result);
+ reject(err);
});
});
- }).catch(function( err) {
+ }).catch(function(err) {
console.error(err);
});
};
@@ -173,8 +174,12 @@
var proto = {};
proto.get = function () {
return new Promise(function(resolve, reject) {
- web3.provider.send({call: property.getter}, function(result) {
- resolve(result);
+ web3.provider.send({call: property.getter}, function(err, result) {
+ if (!err) {
+ resolve(result);
+ return;
+ }
+ reject(err);
});
});
};
@@ -182,12 +187,12 @@
proto.set = function (val) {
return flattenPromise([val]).then(function (args) {
return new Promise(function (resolve) {
- web3.provider.send({call: property.setter, args: args}, function (result) {
- if (result) {
+ web3.provider.send({call: property.setter, args: args}, function (err, result) {
+ if (!err) {
resolve(result);
- } else {
- reject(result);
+ return;
}
+ reject(err);
});
});
}).catch(function (err) {
@@ -218,7 +223,7 @@
var str = "";
var i = 0, l = hex.length;
if (hex.substring(0, 2) == '0x')
- i = 2;
+ i = 2;
for(; i < l; i+=2) {
var code = hex.charCodeAt(i)
if(code == 0) {
@@ -240,7 +245,7 @@
var hex = this.toHex(str);
while(hex.length < pad*2)
hex += "00";
- return "0x" + hex
+ return "0x" + hex;
},
eth: {
@@ -295,11 +300,11 @@
setupMethods(web3.shh, shhMethods());
var ethWatch = {
- changed: 'changed'
+ changed: 'eth_changed'
};
setupMethods(ethWatch, ethWatchMethods());
var shhWatch = {
- changed: 'shhChanged'
+ changed: 'shh_changed'
};
setupMethods(shhWatch, shhWatchMethods());
@@ -410,8 +415,10 @@
};
Filter.prototype.trigger = function(messages) {
- for(var i = 0; i < this.callbacks.length; i++) {
- this.callbacks[i].call(this, messages);
+ if (!(messages instanceof Array) || messages.length) {
+ for(var i = 0; i < this.callbacks.length; i++) {
+ this.callbacks[i].call(this, messages);
+ }
}
};
@@ -440,7 +447,7 @@
if(data._id) {
var cb = web3._callbacks[data._id];
if (cb) {
- cb.call(this, data.data)
+ cb.call(this, data.error, data.data);
delete web3._callbacks[data._id];
}
}
diff --git a/libjsqrc/qt.js b/libjsqrc/qt.js
index f0312eb2f..aedd34236 100644
--- a/libjsqrc/qt.js
+++ b/libjsqrc/qt.js
@@ -2,19 +2,19 @@
This file is part of ethereum.js.
ethereum.js is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
ethereum.js 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.
+ GNU Lesser General Public License for more details.
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU Lesser General Public License
along with ethereum.js. If not, see .
*/
-/** @file ethereum.js
+/** @file qt.js
* @authors:
* Marek Kotewicz
* @date 2014
diff --git a/libjsqrc/setup.js b/libjsqrc/setup.js
index 549222119..5142412a6 100644
--- a/libjsqrc/setup.js
+++ b/libjsqrc/setup.js
@@ -14,7 +14,7 @@
You should have received a copy of the GNU General Public License
along with cpp-ethereum. If not, see .
*/
-/** @file QEthereum.cpp
+/** @file setup.js
* @authors:
* Marek Kotewicz
* @date 2014
diff --git a/liblll/All.h b/liblll/All.h
index ec6989e66..7c4192f62 100644
--- a/liblll/All.h
+++ b/liblll/All.h
@@ -1,6 +1,5 @@
#pragma once
-#include "Assembly.h"
#include "CodeFragment.h"
#include "Compiler.h"
#include "CompilerState.h"
diff --git a/liblll/CMakeLists.txt b/liblll/CMakeLists.txt
index cb50cc36e..8b1581785 100644
--- a/liblll/CMakeLists.txt
+++ b/liblll/CMakeLists.txt
@@ -15,7 +15,7 @@ endif()
include_directories(..)
-target_link_libraries(${EXECUTABLE} evmface)
+target_link_libraries(${EXECUTABLE} evmcore)
target_link_libraries(${EXECUTABLE} devcore)
diff --git a/liblll/CodeFragment.cpp b/liblll/CodeFragment.cpp
index 47df8f3b9..2c200caa5 100644
--- a/liblll/CodeFragment.cpp
+++ b/liblll/CodeFragment.cpp
@@ -25,7 +25,7 @@
#include
#include
#include
-#include
+#include
#include "CompilerState.h"
#include "Parser.h"
using namespace std;
diff --git a/liblll/CodeFragment.h b/liblll/CodeFragment.h
index d6ca86bbe..b24b474da 100644
--- a/liblll/CodeFragment.h
+++ b/liblll/CodeFragment.h
@@ -22,8 +22,8 @@
#pragma once
#include
-#include
-#include "Assembly.h"
+#include
+#include
#include "Exceptions.h"
namespace boost { namespace spirit { class utree; } }
diff --git a/liblll/Exceptions.h b/liblll/Exceptions.h
index c45215f1a..1e9671b36 100644
--- a/liblll/Exceptions.h
+++ b/liblll/Exceptions.h
@@ -32,16 +32,13 @@ namespace eth
class CompilerException: public dev::Exception {};
class InvalidOperation: public CompilerException {};
class IntegerOutOfRange: public CompilerException {};
-class StringTooLong: public CompilerException {};
class EmptyList: public CompilerException {};
class DataNotExecutable: public CompilerException {};
class IncorrectParameterCount: public CompilerException {};
-class InvalidDeposit: public CompilerException {};
class InvalidName: public CompilerException {};
class InvalidMacroArgs: public CompilerException {};
class InvalidLiteral: public CompilerException {};
class BareSymbol: public CompilerException {};
-class ExpectedLiteral: public CompilerException {};
}
}
diff --git a/libpyserpent/CMakeLists.txt b/libpyserpent/CMakeLists.txt
index 5108000f4..e6f32ec81 100644
--- a/libpyserpent/CMakeLists.txt
+++ b/libpyserpent/CMakeLists.txt
@@ -13,7 +13,7 @@ include_directories(..)
target_link_libraries(${EXECUTABLE} serpent)
target_link_libraries(${EXECUTABLE} lll)
-target_link_libraries(${EXECUTABLE} evmface)
+target_link_libraries(${EXECUTABLE} evmcore)
target_link_libraries(${EXECUTABLE} devcore)
target_link_libraries(${EXECUTABLE} ${PYTHON_LS})
diff --git a/libqethereum/QEthereum.cpp b/libqethereum/QEthereum.cpp
index 08165d9db..5e5253829 100644
--- a/libqethereum/QEthereum.cpp
+++ b/libqethereum/QEthereum.cpp
@@ -59,13 +59,13 @@ void QWebThree::poll()
{
if (m_watches.size() > 0)
{
- QString batch = toJsonRpcBatch(m_watches, "changed");
- emit processData(batch, "changed");
+ QString batch = toJsonRpcBatch(m_watches, "eth_changed");
+ emit processData(batch, "eth_changed");
}
if (m_shhWatches.size() > 0)
{
- QString batch = toJsonRpcBatch(m_shhWatches, "shhChanged");
- emit processData(batch, "shhChanged");
+ QString batch = toJsonRpcBatch(m_shhWatches, "shh_changed");
+ emit processData(batch, "shh_changed");
}
}
@@ -73,13 +73,13 @@ void QWebThree::clearWatches()
{
if (m_watches.size() > 0)
{
- QString batch = toJsonRpcBatch(m_watches, "uninstallFilter");
+ QString batch = toJsonRpcBatch(m_watches, "eth_uninstallFilter");
m_watches.clear();
emit processData(batch, "internal");
}
if (m_shhWatches.size() > 0)
{
- QString batch = toJsonRpcBatch(m_shhWatches, "shhUninstallFilter");
+ QString batch = toJsonRpcBatch(m_shhWatches, "shh_uninstallFilter");
m_shhWatches.clear();
emit processData(batch, "internal");
}
@@ -106,7 +106,12 @@ void QWebThree::postMessage(QString _json)
QJsonObject f = QJsonDocument::fromJson(_json.toUtf8()).object();
QString method = f["call"].toString();
- if (!method.compare("uninstallFilter") && f["args"].isArray() && f["args"].toArray().size())
+ if (!method.compare("eth_uninstallFilter") && f["args"].isArray() && f["args"].toArray().size())
+ {
+ int idToRemove = f["args"].toArray()[0].toInt();
+ m_watches.erase(std::remove(m_watches.begin(), m_watches.end(), idToRemove), m_watches.end());
+ }
+ else if (!method.compare("eth_uninstallFilter") && f["args"].isArray() && f["args"].toArray().size())
{
int idToRemove = f["args"].toArray()[0].toInt();
m_watches.erase(std::remove(m_watches.begin(), m_watches.end(), idToRemove), m_watches.end());
@@ -120,6 +125,7 @@ static QString formatOutput(QJsonObject const& _object)
QJsonObject res;
res["_id"] = _object["id"];
res["data"] = _object["result"];
+ res["error"] = _object["error"];
return QString::fromUtf8(QJsonDocument(res).toJson());
}
@@ -128,7 +134,7 @@ void QWebThree::onDataProcessed(QString _json, QString _addInfo)
if (!_addInfo.compare("internal"))
return;
- if (!_addInfo.compare("changed"))
+ if (!_addInfo.compare("eth_changed"))
{
QJsonArray resultsArray = QJsonDocument::fromJson(_json.toUtf8()).array();
for (int i = 0; i < resultsArray.size(); i++)
@@ -145,7 +151,7 @@ void QWebThree::onDataProcessed(QString _json, QString _addInfo)
return;
}
- if (!_addInfo.compare("shhChanged"))
+ if (!_addInfo.compare("shh_changed"))
{
QJsonArray resultsArray = QJsonDocument::fromJson(_json.toUtf8()).array();
for (int i = 0; i < resultsArray.size(); i++)
@@ -164,11 +170,11 @@ void QWebThree::onDataProcessed(QString _json, QString _addInfo)
QJsonObject f = QJsonDocument::fromJson(_json.toUtf8()).object();
- if ((!_addInfo.compare("newFilter") || !_addInfo.compare("newFilterString")) && f.contains("result"))
+ if ((!_addInfo.compare("eth_newFilter") || !_addInfo.compare("eth_newFilterString")) && f.contains("result"))
m_watches.push_back(f["result"].toInt());
- if (!_addInfo.compare("shhNewFilter") && f.contains("result"))
+ else if (!_addInfo.compare("shh_newFilter") && f.contains("result"))
m_shhWatches.push_back(f["result"].toInt());
- if (!_addInfo.compare("newIdentity") && f.contains("result"))
+ else if (!_addInfo.compare("shh_newIdentity") && f.contains("result"))
emit onNewId(f["result"].toString());
response(formatOutput(f));
diff --git a/libqethereum/QmlEthereum.cpp b/libqethereum/QmlEthereum.cpp
index a7ed3df4d..b1b926f42 100644
--- a/libqethereum/QmlEthereum.cpp
+++ b/libqethereum/QmlEthereum.cpp
@@ -4,7 +4,7 @@
#include
#include
#include
-#include
+#include
#include
#include
#include
diff --git a/libserpent/CMakeLists.txt b/libserpent/CMakeLists.txt
index 0090b5dc3..c2fe89cc0 100644
--- a/libserpent/CMakeLists.txt
+++ b/libserpent/CMakeLists.txt
@@ -16,7 +16,7 @@ endif()
include_directories(..)
target_link_libraries(${EXECUTABLE} lll)
-target_link_libraries(${EXECUTABLE} evmface)
+target_link_libraries(${EXECUTABLE} evmcore)
target_link_libraries(${EXECUTABLE} devcore)
if("${TARGET_PLATFORM}" STREQUAL "w64")
diff --git a/libserpent/compiler.cpp b/libserpent/compiler.cpp
index 623ab3950..30628fbc9 100644
--- a/libserpent/compiler.cpp
+++ b/libserpent/compiler.cpp
@@ -131,8 +131,7 @@ programData opcodeify(Node node,
}
// Declare variable
else {
- Node nodelist[] = { };
- return pd(aux, multiToken(nodelist, 0, m), 0);
+ return pd(aux, multiToken(nullptr, 0, m), 0);
}
}
// Define functions (TODO: eventually move to rewriter.cpp, keep
diff --git a/libsolidity/AST.cpp b/libsolidity/AST.cpp
index 44cf39291..70af8f98e 100644
--- a/libsolidity/AST.cpp
+++ b/libsolidity/AST.cpp
@@ -263,6 +263,21 @@ TypeError ASTNode::createTypeError(string const& _description)
return TypeError() << errinfo_sourceLocation(getLocation()) << errinfo_comment(_description);
}
+vector ContractDefinition::getInterfaceFunctions() const
+{
+ vector exportedFunctions;
+ for (ASTPointer const& f: m_definedFunctions)
+ if (f->isPublic() && f->getName() != getName())
+ exportedFunctions.push_back(f.get());
+ auto compareNames = [](FunctionDefinition const* _a, FunctionDefinition const* _b)
+ {
+ return _a->getName().compare(_b->getName()) < 0;
+ };
+
+ sort(exportedFunctions.begin(), exportedFunctions.end(), compareNames);
+ return exportedFunctions;
+}
+
void Block::checkTypeRequirements()
{
for (shared_ptr const& statement: m_statements)
@@ -337,9 +352,11 @@ void ExpressionStatement::checkTypeRequirements()
void Expression::expectType(Type const& _expectedType)
{
checkTypeRequirements();
- if (!getType()->isImplicitlyConvertibleTo(_expectedType))
- BOOST_THROW_EXCEPTION(createTypeError("Type not implicitly convertible to expected type."));
- //@todo provide more information to the exception
+ Type const& type = *getType();
+ if (!type.isImplicitlyConvertibleTo(_expectedType))
+ BOOST_THROW_EXCEPTION(createTypeError("Type " + type.toString() +
+ " not implicitly convertible to expected type "
+ + _expectedType.toString() + "."));
}
void UnaryOperation::checkTypeRequirements()
@@ -363,14 +380,18 @@ void BinaryOperation::checkTypeRequirements()
else if (m_left->getType()->isImplicitlyConvertibleTo(*m_right->getType()))
m_commonType = m_right->getType();
else
- BOOST_THROW_EXCEPTION(createTypeError("No common type found in binary operation."));
+ BOOST_THROW_EXCEPTION(createTypeError("No common type found in binary operation: " +
+ m_left->getType()->toString() + " vs. " +
+ m_right->getType()->toString()));
if (Token::isCompareOp(m_operator))
m_type = make_shared();
else
{
m_type = m_commonType;
if (!m_commonType->acceptsBinaryOperator(m_operator))
- BOOST_THROW_EXCEPTION(createTypeError("Operator not compatible with type."));
+ BOOST_THROW_EXCEPTION(createTypeError("Operator " + string(Token::toString(m_operator)) +
+ " not compatible with type " +
+ m_commonType->toString()));
}
}
@@ -479,6 +500,8 @@ void ElementaryTypeNameExpression::checkTypeRequirements()
void Literal::checkTypeRequirements()
{
m_type = Type::forLiteral(*this);
+ if (!m_type)
+ BOOST_THROW_EXCEPTION(createTypeError("Literal value too large."));
}
}
diff --git a/libsolidity/AST.h b/libsolidity/AST.h
index 793ce863f..7b266f132 100644
--- a/libsolidity/AST.h
+++ b/libsolidity/AST.h
@@ -116,10 +116,12 @@ public:
virtual void accept(ASTVisitor& _visitor) override;
- std::vector> const& getDefinedStructs() { return m_definedStructs; }
- std::vector> const& getStateVariables() { return m_stateVariables; }
- std::vector> const& getDefinedFunctions() { return m_definedFunctions; }
+ std::vector> const& getDefinedStructs() const { return m_definedStructs; }
+ std::vector> const& getStateVariables() const { return m_stateVariables; }
+ std::vector> const& getDefinedFunctions() const { return m_definedFunctions; }
+ /// Returns the functions that make up the calling interface in the intended order.
+ std::vector getInterfaceFunctions() const;
private:
std::vector> m_definedStructs;
std::vector> m_stateVariables;
@@ -135,6 +137,8 @@ public:
Declaration(_location, _name), m_members(_members) {}
virtual void accept(ASTVisitor& _visitor) override;
+ std::vector> const& getMembers() const { return m_members; }
+
private:
std::vector> m_members;
};
@@ -565,12 +569,15 @@ public:
Expression& getLeftExpression() const { return *m_left; }
Expression& getRightExpression() const { return *m_right; }
Token::Value getOperator() const { return m_operator; }
+ Type const& getCommonType() const { return *m_commonType; }
private:
ASTPointer m_left;
Token::Value m_operator;
ASTPointer m_right;
+ /// The common type that is used for the operation, not necessarily the result type (e.g. for
+ /// comparisons, this is always bool).
std::shared_ptr m_commonType;
};
diff --git a/libsolidity/ASTPrinter.cpp b/libsolidity/ASTPrinter.cpp
index eb9d92f08..987ad11cc 100644
--- a/libsolidity/ASTPrinter.cpp
+++ b/libsolidity/ASTPrinter.cpp
@@ -30,8 +30,8 @@ namespace dev
namespace solidity
{
-ASTPrinter::ASTPrinter(ASTPointer const& _ast, string const& _source):
- m_indentation(0), m_source(_source), m_ast(_ast)
+ASTPrinter::ASTPrinter(ASTNode& _ast, string const& _source):
+ m_indentation(0), m_source(_source), m_ast(&_ast)
{
}
@@ -430,8 +430,8 @@ void ASTPrinter::printSourcePart(ASTNode const& _node)
if (!m_source.empty())
{
Location const& location(_node.getLocation());
- *m_ostream << getIndentation() << " Source: |"
- << m_source.substr(location.start, location.end - location.start) << "|" << endl;
+ *m_ostream << getIndentation() << " Source: "
+ << escaped(m_source.substr(location.start, location.end - location.start), false) << endl;
}
}
diff --git a/libsolidity/ASTPrinter.h b/libsolidity/ASTPrinter.h
index e87b2ba3b..e0757fbc4 100644
--- a/libsolidity/ASTPrinter.h
+++ b/libsolidity/ASTPrinter.h
@@ -38,7 +38,7 @@ class ASTPrinter: public ASTVisitor
public:
/// Create a printer for the given abstract syntax tree. If the source is specified,
/// the corresponding parts of the source are printed with each node.
- ASTPrinter(ASTPointer const& _ast, std::string const& _source = std::string());
+ ASTPrinter(ASTNode& _ast, std::string const& _source = std::string());
/// Output the string representation of the AST to _stream.
void print(std::ostream& _stream);
@@ -114,7 +114,7 @@ private:
int m_indentation;
std::string m_source;
- ASTPointer m_ast;
+ ASTNode* m_ast;
std::ostream* m_ostream;
};
diff --git a/libsolidity/CMakeLists.txt b/libsolidity/CMakeLists.txt
index f425bba48..ea2ef4b74 100644
--- a/libsolidity/CMakeLists.txt
+++ b/libsolidity/CMakeLists.txt
@@ -6,18 +6,16 @@ aux_source_directory(. SRC_LIST)
set(EXECUTABLE solidity)
+file(GLOB HEADERS "*.h")
if(ETH_STATIC)
- add_library(${EXECUTABLE} STATIC ${SRC_LIST})
+ add_library(${EXECUTABLE} STATIC ${SRC_LIST} ${HEADERS})
else()
- add_library(${EXECUTABLE} SHARED ${SRC_LIST})
+ add_library(${EXECUTABLE} SHARED ${SRC_LIST} ${HEADERS})
endif()
-file(GLOB HEADERS "*.h")
-
include_directories(..)
-# @todo we only depend on Assembly, not on all of lll
-target_link_libraries(${EXECUTABLE} evmface devcore lll)
+target_link_libraries(${EXECUTABLE} evmcore devcore)
install( TARGETS ${EXECUTABLE} ARCHIVE DESTINATION lib LIBRARY DESTINATION lib )
install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} )
diff --git a/libsolidity/Compiler.cpp b/libsolidity/Compiler.cpp
index d05552b9e..da28ba8a3 100644
--- a/libsolidity/Compiler.cpp
+++ b/libsolidity/Compiler.cpp
@@ -21,6 +21,8 @@
*/
#include
+#include
+#include
#include
#include
#include
@@ -30,11 +32,11 @@ using namespace std;
namespace dev {
namespace solidity {
-bytes Compiler::compile(ContractDefinition& _contract)
+bytes Compiler::compile(ContractDefinition& _contract, bool _optimize)
{
Compiler compiler;
compiler.compileContract(_contract);
- return compiler.m_context.getAssembledBytecode();
+ return compiler.m_context.getAssembledBytecode(_optimize);
}
void Compiler::compileContract(ContractDefinition& _contract)
@@ -42,10 +44,12 @@ void Compiler::compileContract(ContractDefinition& _contract)
m_context = CompilerContext(); // clear it just in case
//@todo constructor
- //@todo register state variables
for (ASTPointer const& function: _contract.getDefinedFunctions())
m_context.addFunction(*function);
+ //@todo sort them?
+ for (ASTPointer const& variable: _contract.getStateVariables())
+ m_context.addStateVariable(*variable);
appendFunctionSelector(_contract.getDefinedFunctions());
for (ASTPointer const& function: _contract.getDefinedFunctions())
@@ -77,35 +81,34 @@ void Compiler::appendFunctionSelector(vector> con
if (publicFunctions.size() > 255)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("More than 255 public functions for contract."));
- //@todo check for calldatasize?
- // retrieve the first byte of the call data
- m_context << u256(0) << eth::Instruction::CALLDATALOAD << u256(0) << eth::Instruction::BYTE;
- // check that it is not too large
- m_context << eth::Instruction::DUP1 << u256(publicFunctions.size() - 1) << eth::Instruction::LT;
- eth::AssemblyItem returnTag = m_context.appendConditionalJump();
+ // retrieve the first byte of the call data, which determines the called function
+ // @todo This code had a jump table in a previous version which was more efficient but also
+ // error prone (due to the optimizer and variable length tag addresses)
+ m_context << u256(1) << u256(0) // some constants
+ << eth::dupInstruction(1) << eth::Instruction::CALLDATALOAD
+ << eth::dupInstruction(2) << eth::Instruction::BYTE
+ << eth::dupInstruction(2);
- // otherwise, jump inside jump table (each entry of the table has size 4)
- m_context << u256(4) << eth::Instruction::MUL;
- eth::AssemblyItem jumpTableStart = m_context.pushNewTag();
- m_context << eth::Instruction::ADD << eth::Instruction::JUMP;
-
- // jump table @todo it could be that the optimizer destroys this
- m_context << jumpTableStart;
+ // stack here: 1 0 0, stack top will be counted up until it matches funid
for (pair> const& f: publicFunctions)
- m_context.appendJumpTo(f.second.second) << eth::Instruction::JUMPDEST;
-
- m_context << returnTag << eth::Instruction::STOP;
+ {
+ eth::AssemblyItem const& callDataUnpackerEntry = f.second.second;
+ m_context << eth::dupInstruction(2) << eth::dupInstruction(2) << eth::Instruction::EQ;
+ m_context.appendConditionalJumpTo(callDataUnpackerEntry);
+ m_context << eth::dupInstruction(4) << eth::Instruction::ADD;
+ //@todo avoid the last ADD (or remove it in the optimizer)
+ }
+ m_context << eth::Instruction::STOP; // function not found
for (pair> const& f: publicFunctions)
{
FunctionDefinition const& function = *f.second.first;
- m_context << f.second.second;
-
+ eth::AssemblyItem const& callDataUnpackerEntry = f.second.second;
+ m_context << callDataUnpackerEntry;
eth::AssemblyItem returnTag = m_context.pushNewTag();
appendCalldataUnpacker(function);
m_context.appendJumpTo(m_context.getFunctionEntryLabel(function));
m_context << returnTag;
-
appendReturnValuePacker(function);
}
}
@@ -122,7 +125,7 @@ void Compiler::appendCalldataUnpacker(FunctionDefinition const& _function)
if (numBytes == 0)
BOOST_THROW_EXCEPTION(CompilerError()
<< errinfo_sourceLocation(var->getLocation())
- << errinfo_comment("Type not yet supported."));
+ << errinfo_comment("Type " + var->getType()->toString() + " not yet supported."));
if (numBytes == 32)
m_context << u256(dataOffset) << eth::Instruction::CALLDATALOAD;
else
@@ -139,11 +142,12 @@ void Compiler::appendReturnValuePacker(FunctionDefinition const& _function)
vector> const& parameters = _function.getReturnParameters();
for (unsigned i = 0; i < parameters.size(); ++i)
{
- unsigned numBytes = parameters[i]->getType()->getCalldataEncodedSize();
+ Type const& paramType = *parameters[i]->getType();
+ unsigned numBytes = paramType.getCalldataEncodedSize();
if (numBytes == 0)
BOOST_THROW_EXCEPTION(CompilerError()
<< errinfo_sourceLocation(parameters[i]->getLocation())
- << errinfo_comment("Type not yet supported."));
+ << errinfo_comment("Type " + paramType.toString() + " not yet supported."));
m_context << eth::dupInstruction(parameters.size() - i);
if (numBytes != 32)
m_context << (u256(1) << ((32 - numBytes) * 8)) << eth::Instruction::MUL;
@@ -271,8 +275,9 @@ bool Compiler::visit(Return& _return)
{
ExpressionCompiler::compileExpression(m_context, *expression);
VariableDeclaration const& firstVariable = *_return.getFunctionReturnParameters().getParameters().front();
- ExpressionCompiler::cleanHigherOrderBitsIfNeeded(*expression->getType(), *firstVariable.getType());
- int stackPosition = m_context.getStackPositionOfVariable(firstVariable);
+ ExpressionCompiler::appendTypeConversion(m_context, *expression->getType(), *firstVariable.getType());
+
+ unsigned stackPosition = m_context.baseToCurrentStackOffset(m_context.getBaseStackOffsetOfVariable(firstVariable));
m_context << eth::swapInstruction(stackPosition) << eth::Instruction::POP;
}
m_context.appendJumpTo(m_returnTag);
@@ -284,9 +289,11 @@ bool Compiler::visit(VariableDefinition& _variableDefinition)
if (Expression* expression = _variableDefinition.getExpression())
{
ExpressionCompiler::compileExpression(m_context, *expression);
- ExpressionCompiler::cleanHigherOrderBitsIfNeeded(*expression->getType(),
- *_variableDefinition.getDeclaration().getType());
- int stackPosition = m_context.getStackPositionOfVariable(_variableDefinition.getDeclaration());
+ ExpressionCompiler::appendTypeConversion(m_context,
+ *expression->getType(),
+ *_variableDefinition.getDeclaration().getType());
+ unsigned baseStackOffset = m_context.getBaseStackOffsetOfVariable(_variableDefinition.getDeclaration());
+ unsigned stackPosition = m_context.baseToCurrentStackOffset(baseStackOffset);
m_context << eth::swapInstruction(stackPosition) << eth::Instruction::POP;
}
return false;
diff --git a/libsolidity/Compiler.h b/libsolidity/Compiler.h
index 4e4d90d45..d931f5359 100644
--- a/libsolidity/Compiler.h
+++ b/libsolidity/Compiler.h
@@ -33,11 +33,11 @@ public:
Compiler(): m_returnTag(m_context.newTag()) {}
void compileContract(ContractDefinition& _contract);
- bytes getAssembledBytecode() { return m_context.getAssembledBytecode(); }
+ bytes getAssembledBytecode(bool _optimize = false) { return m_context.getAssembledBytecode(_optimize); }
void streamAssembly(std::ostream& _stream) const { m_context.streamAssembly(_stream); }
/// Compile the given contract and return the EVM bytecode.
- static bytes compile(ContractDefinition& _contract);
+ static bytes compile(ContractDefinition& _contract, bool _optimize);
private:
/// Creates a new compiler context / assembly and packs the current code into the data part.
diff --git a/libsolidity/CompilerContext.cpp b/libsolidity/CompilerContext.cpp
index 99cf090e0..3c1acdfa7 100644
--- a/libsolidity/CompilerContext.cpp
+++ b/libsolidity/CompilerContext.cpp
@@ -30,6 +30,12 @@ using namespace std;
namespace dev {
namespace solidity {
+void CompilerContext::addStateVariable(VariableDeclaration const& _declaration)
+{
+ m_stateVariables[&_declaration] = m_stateVariablesSize;
+ m_stateVariablesSize += _declaration.getType()->getStorageSize();
+}
+
void CompilerContext::initializeLocalVariables(unsigned _numVariables)
{
if (_numVariables > 0)
@@ -41,12 +47,9 @@ void CompilerContext::initializeLocalVariables(unsigned _numVariables)
}
}
-int CompilerContext::getStackPositionOfVariable(Declaration const& _declaration)
+bool CompilerContext::isLocalVariable(Declaration const* _declaration) const
{
- auto res = find(begin(m_localVariables), end(m_localVariables), &_declaration);
- if (asserts(res != m_localVariables.end()))
- BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Variable not found on stack."));
- return end(m_localVariables) - res - 1 + m_asm.deposit();
+ return std::find(m_localVariables.begin(), m_localVariables.end(), _declaration) != m_localVariables.end();
}
eth::AssemblyItem CompilerContext::getFunctionEntryLabel(FunctionDefinition const& _function) const
@@ -57,5 +60,28 @@ eth::AssemblyItem CompilerContext::getFunctionEntryLabel(FunctionDefinition cons
return res->second.tag();
}
+unsigned CompilerContext::getBaseStackOffsetOfVariable(Declaration const& _declaration) const
+{
+ auto res = find(begin(m_localVariables), end(m_localVariables), &_declaration);
+ if (asserts(res != m_localVariables.end()))
+ BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Variable not found on stack."));
+ return unsigned(end(m_localVariables) - res - 1);
+}
+
+unsigned CompilerContext::baseToCurrentStackOffset(unsigned _baseOffset) const
+{
+ return _baseOffset + m_asm.deposit();
+}
+
+u256 CompilerContext::getStorageLocationOfVariable(const Declaration& _declaration) const
+{
+ auto it = m_stateVariables.find(&_declaration);
+ if (it == m_stateVariables.end())
+ BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Variable not found in storage."));
+ return it->second;
+}
+
+
+
}
}
diff --git a/libsolidity/CompilerContext.h b/libsolidity/CompilerContext.h
index 46c4c72ab..562c29321 100644
--- a/libsolidity/CompilerContext.h
+++ b/libsolidity/CompilerContext.h
@@ -23,8 +23,8 @@
#pragma once
#include
-#include
-#include
+#include
+#include
#include
namespace dev {
@@ -38,19 +38,28 @@ namespace solidity {
class CompilerContext
{
public:
- CompilerContext() {}
+ CompilerContext(): m_stateVariablesSize(0) {}
+ void addStateVariable(VariableDeclaration const& _declaration);
void startNewFunction() { m_localVariables.clear(); m_asm.setDeposit(0); }
void initializeLocalVariables(unsigned _numVariables);
void addVariable(VariableDeclaration const& _declaration) { m_localVariables.push_back(&_declaration); }
- /// Returns the distance of the given local variable from the top of the stack.
- int getStackPositionOfVariable(Declaration const& _declaration);
-
void addFunction(FunctionDefinition const& _function) { m_functionEntryLabels.insert(std::make_pair(&_function, m_asm.newTag())); }
- eth::AssemblyItem getFunctionEntryLabel(FunctionDefinition const& _function) const;
void adjustStackOffset(int _adjustment) { m_asm.adjustDeposit(_adjustment); }
+ bool isFunctionDefinition(Declaration const* _declaration) const { return m_functionEntryLabels.count(_declaration); }
+ bool isLocalVariable(Declaration const* _declaration) const;
+ bool isStateVariable(Declaration const* _declaration) const { return m_stateVariables.count(_declaration); }
+
+ eth::AssemblyItem getFunctionEntryLabel(FunctionDefinition const& _function) const;
+ /// Returns the distance of the given local variable from the top of the local variable stack.
+ unsigned getBaseStackOffsetOfVariable(Declaration const& _declaration) const;
+ /// If supplied by a value returned by @ref getBaseStackOffsetOfVariable(variable), returns
+ /// the distance of that variable from the current top of the stack.
+ unsigned baseToCurrentStackOffset(unsigned _baseOffset) const;
+ u256 getStorageLocationOfVariable(Declaration const& _declaration) const;
+
/// Appends a JUMPI instruction to a new tag and @returns the tag
eth::AssemblyItem appendConditionalJump() { return m_asm.appendJumpI().tag(); }
/// Appends a JUMPI instruction to @a _tag
@@ -75,14 +84,18 @@ public:
eth::Assembly const& getAssembly() const { return m_asm; }
void streamAssembly(std::ostream& _stream) const { _stream << m_asm; }
- bytes getAssembledBytecode() const { return m_asm.assemble(); }
+ bytes getAssembledBytecode(bool _optimize = false) { return m_asm.optimise(_optimize).assemble(); }
private:
eth::Assembly m_asm;
+ /// Size of the state variables, offset of next variable to be added.
+ u256 m_stateVariablesSize;
+ /// Storage offsets of state variables
+ std::map m_stateVariables;
/// Offsets of local variables on the stack.
std::vector m_localVariables;
/// Labels pointing to the entry points of funcitons.
- std::map m_functionEntryLabels;
+ std::map m_functionEntryLabels;
};
}
diff --git a/libsolidity/CompilerStack.cpp b/libsolidity/CompilerStack.cpp
index bbd693ae5..d87c27916 100644
--- a/libsolidity/CompilerStack.cpp
+++ b/libsolidity/CompilerStack.cpp
@@ -34,16 +34,101 @@ namespace dev
namespace solidity
{
-bytes CompilerStack::compile(std::string const& _sourceCode, shared_ptr _scanner)
+void CompilerStack::setSource(string const& _sourceCode)
{
- if (!_scanner)
- _scanner = make_shared();
- _scanner->reset(CharStream(_sourceCode));
+ reset();
+ m_scanner = make_shared(CharStream(_sourceCode));
+}
+
+void CompilerStack::parse()
+{
+ if (!m_scanner)
+ BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Source not available."));
+ m_contractASTNode = Parser().parse(m_scanner);
+ NameAndTypeResolver().resolveNamesAndTypes(*m_contractASTNode);
+ m_parseSuccessful = true;
+}
+
+void CompilerStack::parse(string const& _sourceCode)
+{
+ setSource(_sourceCode);
+ parse();
+}
+
+bytes const& CompilerStack::compile(bool _optimize)
+{
+ if (!m_parseSuccessful)
+ BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+ m_bytecode.clear();
+ m_compiler = make_shared();
+ m_compiler->compileContract(*m_contractASTNode);
+ return m_bytecode = m_compiler->getAssembledBytecode(_optimize);
+}
- ASTPointer contract = Parser().parse(_scanner);
- NameAndTypeResolver().resolveNamesAndTypes(*contract);
- return Compiler::compile(*contract);
+bytes const& CompilerStack::compile(string const& _sourceCode, bool _optimize)
+{
+ parse(_sourceCode);
+ return compile(_optimize);
}
+void CompilerStack::streamAssembly(ostream& _outStream)
+{
+ if (!m_compiler || m_bytecode.empty())
+ BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
+ m_compiler->streamAssembly(_outStream);
+}
+
+string const& CompilerStack::getInterface()
+{
+ if (!m_parseSuccessful)
+ BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+ if (m_interface.empty())
+ {
+ stringstream interface;
+ interface << '[';
+ vector exportedFunctions = m_contractASTNode->getInterfaceFunctions();
+ unsigned functionsCount = exportedFunctions.size();
+ for (FunctionDefinition const* f: exportedFunctions)
+ {
+ auto streamVariables = [&](vector> const& _vars)
+ {
+ unsigned varCount = _vars.size();
+ for (ASTPointer const& var: _vars)
+ {
+ interface << "{"
+ << "\"name\":" << escaped(var->getName(), false) << ","
+ << "\"type\":" << escaped(var->getType()->toString(), false)
+ << "}";
+ if (--varCount > 0)
+ interface << ",";
+ }
+ };
+
+ interface << '{'
+ << "\"name\":" << escaped(f->getName(), false) << ","
+ << "\"inputs\":[";
+ streamVariables(f->getParameters());
+ interface << "],"
+ << "\"outputs\":[";
+ streamVariables(f->getReturnParameters());
+ interface << "]"
+ << "}";
+ if (--functionsCount > 0)
+ interface << ",";
+ }
+ interface << ']';
+ m_interface = interface.str();
+ }
+ return m_interface;
+}
+
+bytes CompilerStack::staticCompile(std::string const& _sourceCode, bool _optimize)
+{
+ CompilerStack stack;
+ return stack.compile(_sourceCode, _optimize);
+}
+
+
+
}
}
diff --git a/libsolidity/CompilerStack.h b/libsolidity/CompilerStack.h
index 9f3f81c04..2fb505897 100644
--- a/libsolidity/CompilerStack.h
+++ b/libsolidity/CompilerStack.h
@@ -22,6 +22,7 @@
#pragma once
+#include
#include
#include
#include
@@ -30,13 +31,51 @@ namespace dev {
namespace solidity {
class Scanner; // forward
+class ContractDefinition; // forward
+class Compiler; // forward
+/**
+ * Easy to use and self-contained Solidity compiler with as few header dependencies as possible.
+ * It holds state and can be used to either step through the compilation stages (and abort e.g.
+ * before compilation to bytecode) or run the whole compilation in one call.
+ */
class CompilerStack
{
public:
+ CompilerStack() {}
+ void reset() { *this = CompilerStack(); }
+ void setSource(std::string const& _sourceCode);
+ void parse();
+ void parse(std::string const& _sourceCode);
+ /// Compiles the contract that was previously parsed.
+ bytes const& compile(bool _optimize = false);
+ /// Parses and compiles the given source code.
+ bytes const& compile(std::string const& _sourceCode, bool _optimize = false);
+
+ bytes const& getBytecode() const { return m_bytecode; }
+ /// Streams a verbose version of the assembly to @a _outStream.
+ /// Prerequisite: Successful compilation.
+ void streamAssembly(std::ostream& _outStream);
+
+ /// Returns a string representing the contract interface in JSON.
+ /// Prerequisite: Successful call to parse or compile.
+ std::string const& getInterface();
+
+ /// Returns the previously used scanner, useful for counting lines during error reporting.
+ Scanner const& getScanner() const { return *m_scanner; }
+ ContractDefinition& getAST() const { return *m_contractASTNode; }
+
/// Compile the given @a _sourceCode to bytecode. If a scanner is provided, it is used for
/// scanning the source code - this is useful for printing exception information.
- static bytes compile(std::string const& _sourceCode, std::shared_ptr _scanner = std::shared_ptr());
+ static bytes staticCompile(std::string const& _sourceCode, bool _optimize = false);
+
+private:
+ std::shared_ptr m_scanner;
+ std::shared_ptr m_contractASTNode;
+ bool m_parseSuccessful;
+ std::string m_interface;
+ std::shared_ptr m_compiler;
+ bytes m_bytecode;
};
}
diff --git a/libsolidity/ExpressionCompiler.cpp b/libsolidity/ExpressionCompiler.cpp
index d23579b11..05bbb0916 100644
--- a/libsolidity/ExpressionCompiler.cpp
+++ b/libsolidity/ExpressionCompiler.cpp
@@ -37,25 +37,25 @@ void ExpressionCompiler::compileExpression(CompilerContext& _context, Expression
_expression.accept(compiler);
}
-bool ExpressionCompiler::visit(Assignment& _assignment)
+void ExpressionCompiler::appendTypeConversion(CompilerContext& _context,
+ Type const& _typeOnStack, Type const& _targetType)
{
- m_currentLValue = nullptr;
+ ExpressionCompiler compiler(_context);
+ compiler.appendTypeConversion(_typeOnStack, _targetType);
+}
- Expression& rightHandSide = _assignment.getRightHandSide();
- rightHandSide.accept(*this);
- Type const& resultType = *_assignment.getType();
- cleanHigherOrderBitsIfNeeded(*rightHandSide.getType(), resultType);
+bool ExpressionCompiler::visit(Assignment& _assignment)
+{
+ _assignment.getRightHandSide().accept(*this);
+ appendTypeConversion(*_assignment.getRightHandSide().getType(), *_assignment.getType());
+ m_currentLValue.reset();
_assignment.getLeftHandSide().accept(*this);
Token::Value op = _assignment.getAssignmentOperator();
- if (op != Token::ASSIGN)
- {
- // compound assignment
- m_context << eth::Instruction::SWAP1;
- appendOrdinaryBinaryOperatorCode(Token::AssignmentToBinaryOp(op), resultType);
- }
+ if (op != Token::ASSIGN) // compound assignment
+ appendOrdinaryBinaryOperatorCode(Token::AssignmentToBinaryOp(op), *_assignment.getType());
else
- m_context << eth::Instruction::POP; //@todo do not retrieve the value in the first place
+ m_context << eth::Instruction::POP;
storeInLValue(_assignment);
return false;
@@ -92,10 +92,7 @@ void ExpressionCompiler::endVisit(UnaryOperation& _unaryOperation)
m_context << eth::Instruction::ADD;
else
m_context << eth::Instruction::SWAP1 << eth::Instruction::SUB; // @todo avoid the swap
- if (_unaryOperation.isPrefixOperation())
- storeInLValue(_unaryOperation);
- else
- moveToLValue(_unaryOperation);
+ storeInLValue(_unaryOperation, !_unaryOperation.isPrefixOperation());
break;
case Token::ADD: // +
// unary add, so basically no-op
@@ -113,31 +110,26 @@ bool ExpressionCompiler::visit(BinaryOperation& _binaryOperation)
{
Expression& leftExpression = _binaryOperation.getLeftExpression();
Expression& rightExpression = _binaryOperation.getRightExpression();
- Type const& resultType = *_binaryOperation.getType();
+ Type const& commonType = _binaryOperation.getCommonType();
Token::Value const op = _binaryOperation.getOperator();
- if (op == Token::AND || op == Token::OR)
- {
- // special case: short-circuiting
+ if (op == Token::AND || op == Token::OR) // special case: short-circuiting
appendAndOrOperatorCode(_binaryOperation);
- }
- else if (Token::isCompareOp(op))
- {
- leftExpression.accept(*this);
- rightExpression.accept(*this);
-
- // the types to compare have to be the same, but the resulting type is always bool
- if (asserts(*leftExpression.getType() == *rightExpression.getType()))
- BOOST_THROW_EXCEPTION(InternalCompilerError());
- appendCompareOperatorCode(op, *leftExpression.getType());
- }
else
{
- leftExpression.accept(*this);
- cleanHigherOrderBitsIfNeeded(*leftExpression.getType(), resultType);
+ bool cleanupNeeded = false;
+ if (commonType.getCategory() == Type::Category::INTEGER)
+ if (Token::isCompareOp(op) || op == Token::DIV || op == Token::MOD)
+ cleanupNeeded = true;
+
rightExpression.accept(*this);
- cleanHigherOrderBitsIfNeeded(*rightExpression.getType(), resultType);
- appendOrdinaryBinaryOperatorCode(op, resultType);
+ appendTypeConversion(*rightExpression.getType(), commonType, cleanupNeeded);
+ leftExpression.accept(*this);
+ appendTypeConversion(*leftExpression.getType(), commonType, cleanupNeeded);
+ if (Token::isCompareOp(op))
+ appendCompareOperatorCode(op, commonType);
+ else
+ appendOrdinaryBinaryOperatorCode(op, commonType);
}
// do not visit the child nodes, we already did that explicitly
@@ -153,15 +145,19 @@ bool ExpressionCompiler::visit(FunctionCall& _functionCall)
BOOST_THROW_EXCEPTION(InternalCompilerError());
Expression& firstArgument = *_functionCall.getArguments().front();
firstArgument.accept(*this);
- cleanHigherOrderBitsIfNeeded(*firstArgument.getType(), *_functionCall.getType());
+ appendTypeConversion(*firstArgument.getType(), *_functionCall.getType());
}
else
{
// Calling convention: Caller pushes return address and arguments
// Callee removes them and pushes return values
- m_currentLValue = nullptr;
+ m_currentLValue.reset();
_functionCall.getExpression().accept(*this);
- FunctionDefinition const& function = dynamic_cast(*m_currentLValue);
+ if (asserts(m_currentLValue.isInCode()))
+ BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Code reference expected."));
+ eth::AssemblyItem functionTag(eth::PushTag, m_currentLValue.location);
+
+ FunctionDefinition const& function = dynamic_cast(*_functionCall.getExpression().getType()).getFunction();
eth::AssemblyItem returnLabel = m_context.pushNewTag();
std::vector