Genoil
9 years ago
67 changed files with 7 additions and 8513 deletions
@ -1,19 +0,0 @@ |
|||||
cmake_policy(SET CMP0015 NEW) |
|
||||
set(CMAKE_AUTOMOC OFF) |
|
||||
|
|
||||
aux_source_directory(. SRC_LIST) |
|
||||
|
|
||||
include_directories(BEFORE ..) |
|
||||
include_directories(${DB_INCLUDE_DIRS}) |
|
||||
|
|
||||
set(EXECUTABLE abi) |
|
||||
|
|
||||
add_executable(${EXECUTABLE} ${SRC_LIST}) |
|
||||
|
|
||||
target_link_libraries(${EXECUTABLE} ethereum) |
|
||||
|
|
||||
if (APPLE) |
|
||||
install(TARGETS ${EXECUTABLE} DESTINATION bin) |
|
||||
else() |
|
||||
eth_install_executable(${EXECUTABLE}) |
|
||||
endif() |
|
||||
@ -1,769 +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 <http://www.gnu.org/licenses/>.
|
|
||||
*/ |
|
||||
/** @file main.cpp
|
|
||||
* @author Gav Wood <i@gavwood.com> |
|
||||
* @date 2014 |
|
||||
* RLP tool. |
|
||||
*/ |
|
||||
#include <fstream> |
|
||||
#include <iostream> |
|
||||
#include <boost/regex.hpp> |
|
||||
#include <boost/algorithm/string.hpp> |
|
||||
#include "../test/JsonSpiritHeaders.h" |
|
||||
#include <libdevcore/CommonIO.h> |
|
||||
#include <libdevcore/RLP.h> |
|
||||
#include <libdevcore/SHA3.h> |
|
||||
#include <libethereum/Client.h> |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
namespace js = json_spirit; |
|
||||
|
|
||||
void help() |
|
||||
{ |
|
||||
cout |
|
||||
<< "Usage abi enc <method_name> (<arg1>, (<arg2>, ... ))" << endl |
|
||||
<< " abi enc -a <abi.json> <method_name> (<arg1>, (<arg2>, ... ))" << endl |
|
||||
<< " abi dec -a <abi.json> [ <signature> | <unique_method_name> ]" << endl |
|
||||
<< "Options:" << endl |
|
||||
<< " -a,--abi-file <filename> Specify the JSON ABI file." << endl |
|
||||
<< " -h,--help Print this help message and exit." << endl |
|
||||
<< " -V,--version Show the version and exit." << endl |
|
||||
<< "Input options:" << endl |
|
||||
<< " -f,--format-prefix Require all input formats to be prefixed e.g. 0x for hex, + for decimal, ' for binary." << endl |
|
||||
<< " -F,--no-format-prefix Require no input format to be prefixed." << endl |
|
||||
<< " -t,--typing Require all arguments to be typed e.g. b32: (bytes32), u64: (uint64), b[]: (byte[]), i: (int256)." << endl |
|
||||
<< " -T,--no-typing Require no arguments to be typed." << endl |
|
||||
<< "Output options:" << endl |
|
||||
<< " -i,--index <n> Output only the nth (counting from 0) return value." << endl |
|
||||
<< " -d,--decimal All data should be displayed as decimal." << endl |
|
||||
<< " -x,--hex Display all data as hex." << endl |
|
||||
<< " -b,--binary Display all data as binary." << endl |
|
||||
<< " -p,--prefix Prefix by a base identifier." << endl |
|
||||
; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
void version() |
|
||||
{ |
|
||||
cout << "abi version " << dev::Version << endl; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
enum class Mode |
|
||||
{ |
|
||||
Encode, |
|
||||
Decode |
|
||||
}; |
|
||||
|
|
||||
enum class Encoding |
|
||||
{ |
|
||||
Auto, |
|
||||
Decimal, |
|
||||
Hex, |
|
||||
Binary, |
|
||||
}; |
|
||||
|
|
||||
enum class Tristate |
|
||||
{ |
|
||||
False = false, |
|
||||
True = true, |
|
||||
Mu |
|
||||
}; |
|
||||
|
|
||||
enum class Format |
|
||||
{ |
|
||||
Binary, |
|
||||
Hex, |
|
||||
Decimal, |
|
||||
Open, |
|
||||
Close |
|
||||
}; |
|
||||
|
|
||||
struct InvalidUserString: public Exception {}; |
|
||||
struct InvalidFormat: public Exception {}; |
|
||||
|
|
||||
enum class Base |
|
||||
{ |
|
||||
Unknown, |
|
||||
Bytes, |
|
||||
Address, |
|
||||
Int, |
|
||||
Uint, |
|
||||
Fixed |
|
||||
}; |
|
||||
|
|
||||
static const map<Base, string> s_bases = |
|
||||
{ |
|
||||
{ Base::Bytes, "bytes" }, |
|
||||
{ Base::Address, "address" }, |
|
||||
{ Base::Int, "int" }, |
|
||||
{ Base::Uint, "uint" }, |
|
||||
{ Base::Fixed, "fixed" } |
|
||||
}; |
|
||||
|
|
||||
struct EncodingPrefs |
|
||||
{ |
|
||||
Encoding e = Encoding::Auto; |
|
||||
bool prefix = true; |
|
||||
}; |
|
||||
|
|
||||
struct ABIType |
|
||||
{ |
|
||||
Base base = Base::Unknown; |
|
||||
unsigned size = 32; |
|
||||
unsigned ssize = 0; |
|
||||
vector<int> dims; |
|
||||
string name; |
|
||||
ABIType() = default; |
|
||||
ABIType(std::string const& _type, std::string const& _name): |
|
||||
name(_name) |
|
||||
{ |
|
||||
string rest; |
|
||||
for (auto const& i: s_bases) |
|
||||
if (boost::algorithm::starts_with(_type, i.second)) |
|
||||
{ |
|
||||
base = i.first; |
|
||||
rest = _type.substr(i.second.size()); |
|
||||
} |
|
||||
if (base == Base::Unknown) |
|
||||
throw InvalidFormat(); |
|
||||
boost::regex r("(\\d*)(x(\\d+))?((\\[\\d*\\])*)"); |
|
||||
boost::smatch res; |
|
||||
boost::regex_match(rest, res, r); |
|
||||
size = res[1].length() > 0 ? stoi(res[1]) : 0; |
|
||||
ssize = res[3].length() > 0 ? stoi(res[3]) : 0; |
|
||||
boost::regex r2("\\[(\\d*)\\](.*)"); |
|
||||
for (rest = res[4]; boost::regex_match(rest, res, r2); rest = res[2]) |
|
||||
dims.push_back(!res[1].length() ? -1 : stoi(res[1])); |
|
||||
} |
|
||||
|
|
||||
ABIType(std::string const& _s) |
|
||||
{ |
|
||||
if (_s.size() < 1) |
|
||||
return; |
|
||||
switch (_s[0]) |
|
||||
{ |
|
||||
case 'b': base = Base::Bytes; break; |
|
||||
case 'a': base = Base::Address; break; |
|
||||
case 'i': base = Base::Int; break; |
|
||||
case 'u': base = Base::Uint; break; |
|
||||
case 'f': base = Base::Fixed; break; |
|
||||
default: throw InvalidFormat(); |
|
||||
} |
|
||||
if (_s.size() < 2) |
|
||||
{ |
|
||||
if (base == Base::Fixed) |
|
||||
size = ssize = 16; |
|
||||
else if (base == Base::Address || base == Base::Bytes) |
|
||||
size = 0; |
|
||||
else |
|
||||
size = 32; |
|
||||
return; |
|
||||
} |
|
||||
strings d; |
|
||||
boost::algorithm::split(d, _s, boost::is_any_of("*")); |
|
||||
string s = d[0]; |
|
||||
if (s.find_first_of('x') == string::npos) |
|
||||
size = stoi(s.substr(1)); |
|
||||
else |
|
||||
{ |
|
||||
size = stoi(s.substr(1, s.find_first_of('x') - 1)); |
|
||||
ssize = stoi(s.substr(s.find_first_of('x') + 1)); |
|
||||
} |
|
||||
for (unsigned i = 1; i < d.size(); ++i) |
|
||||
if (d[i].empty()) |
|
||||
dims.push_back(-1); |
|
||||
else |
|
||||
dims.push_back(stoi(d[i])); |
|
||||
} |
|
||||
|
|
||||
string canon() const |
|
||||
{ |
|
||||
string ret; |
|
||||
switch (base) |
|
||||
{ |
|
||||
case Base::Bytes: ret = "bytes" + (size > 0 ? toString(size) : ""); break; |
|
||||
case Base::Address: ret = "address"; break; |
|
||||
case Base::Int: ret = "int" + toString(size); break; |
|
||||
case Base::Uint: ret = "uint" + toString(size); break; |
|
||||
case Base::Fixed: ret = "fixed" + toString(size) + "x" + toString(ssize); break; |
|
||||
default: throw InvalidFormat(); |
|
||||
} |
|
||||
for (int i: dims) |
|
||||
ret += "[" + ((i > -1) ? toString(i) : "") + "]"; |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
bool isBytes() const { return base == Base::Bytes && !size; } |
|
||||
|
|
||||
string render(bytes const& _data, EncodingPrefs _e) const |
|
||||
{ |
|
||||
if (base == Base::Uint || base == Base::Int) |
|
||||
{ |
|
||||
if (_e.e == Encoding::Hex) |
|
||||
return (_e.prefix ? "0x" : "") + toHex(toCompactBigEndian(fromBigEndian<bigint>(bytesConstRef(&_data).cropped(32 - size / 8)))); |
|
||||
else |
|
||||
{ |
|
||||
bigint i = fromBigEndian<bigint>(bytesConstRef(&_data).cropped(32 - size / 8)); |
|
||||
if (base == Base::Int && i > (bigint(1) << (size - 1))) |
|
||||
i -= (bigint(1) << size); |
|
||||
return toString(i); |
|
||||
} |
|
||||
} |
|
||||
else if (base == Base::Address) |
|
||||
{ |
|
||||
Address a = Address(h256(_data), Address::AlignRight); |
|
||||
return _e.e == Encoding::Binary ? asString(a.asBytes()) : ((_e.prefix ? "0x" : "") + toString(a)); |
|
||||
} |
|
||||
else if (isBytes()) |
|
||||
{ |
|
||||
return _e.e == Encoding::Binary ? asString(_data) : ((_e.prefix ? "0x" : "") + toHex(_data)); |
|
||||
} |
|
||||
else if (base == Base::Bytes) |
|
||||
{ |
|
||||
bytesConstRef b(&_data); |
|
||||
b = b.cropped(0, size); |
|
||||
return _e.e == Encoding::Binary ? asString(b) : ((_e.prefix ? "0x" : "") + toHex(b)); |
|
||||
} |
|
||||
else |
|
||||
throw InvalidFormat(); |
|
||||
} |
|
||||
|
|
||||
bytes unrender(bytes const& _data, Format _f) const |
|
||||
{ |
|
||||
if (isBytes()) |
|
||||
{ |
|
||||
auto ret = _data; |
|
||||
while (ret.size() % 32 != 0) |
|
||||
ret.push_back(0); |
|
||||
return ret; |
|
||||
} |
|
||||
else |
|
||||
return aligned(_data, _f, 32); |
|
||||
} |
|
||||
|
|
||||
void noteHexInput(unsigned _nibbles) { if (base == Base::Unknown) { if (_nibbles == 40) base = Base::Address; else { base = Base::Bytes; size = _nibbles / 2; } } } |
|
||||
void noteBinaryInput() { if (base == Base::Unknown) { base = Base::Bytes; size = 32; } } |
|
||||
void noteDecimalInput() { if (base == Base::Unknown) { base = Base::Uint; size = 32; } } |
|
||||
|
|
||||
bytes aligned(bytes const& _b, Format _f, unsigned _length) const |
|
||||
{ |
|
||||
bytes ret = _b; |
|
||||
while (ret.size() < _length) |
|
||||
if (base == Base::Bytes || (base == Base::Unknown && _f == Format::Binary)) |
|
||||
ret.push_back(0); |
|
||||
else |
|
||||
ret.insert(ret.begin(), 0); |
|
||||
while (ret.size() > _length) |
|
||||
if (base == Base::Bytes || (base == Base::Unknown && _f == Format::Binary)) |
|
||||
ret.pop_back(); |
|
||||
else |
|
||||
ret.erase(ret.begin()); |
|
||||
return ret; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
tuple<bytes, ABIType, Format> fromUser(std::string const& _arg, Tristate _prefix, Tristate _typing) |
|
||||
{ |
|
||||
ABIType type; |
|
||||
string val; |
|
||||
if (_typing == Tristate::True || (_typing == Tristate::Mu && _arg.find(':') != string::npos)) |
|
||||
{ |
|
||||
if (_arg.find(':') == string::npos) |
|
||||
throw InvalidUserString(); |
|
||||
type = ABIType(_arg.substr(0, _arg.find(':'))); |
|
||||
val = _arg.substr(_arg.find(':') + 1); |
|
||||
} |
|
||||
else |
|
||||
val = _arg; |
|
||||
|
|
||||
if (_prefix != Tristate::False) |
|
||||
{ |
|
||||
if (val.substr(0, 2) == "0x") |
|
||||
{ |
|
||||
type.noteHexInput(val.size() - 2); |
|
||||
return make_tuple(fromHex(val), type, Format::Hex); |
|
||||
} |
|
||||
if (val.substr(0, 1) == "+") |
|
||||
{ |
|
||||
type.noteDecimalInput(); |
|
||||
return make_tuple(toCompactBigEndian(bigint(val.substr(1))), type, Format::Decimal); |
|
||||
} |
|
||||
if (val.substr(0, 1) == "'") |
|
||||
{ |
|
||||
type.noteBinaryInput(); |
|
||||
return make_tuple(asBytes(val.substr(1)), type, Format::Binary); |
|
||||
} |
|
||||
if (val == "[") |
|
||||
return make_tuple(bytes(), type, Format::Open); |
|
||||
if (val == "]") |
|
||||
return make_tuple(bytes(), type, Format::Close); |
|
||||
} |
|
||||
if (_prefix != Tristate::True) |
|
||||
{ |
|
||||
if (val.find_first_not_of("0123456789") == string::npos) |
|
||||
{ |
|
||||
type.noteDecimalInput(); |
|
||||
return make_tuple(toCompactBigEndian(bigint(val)), type, Format::Decimal); |
|
||||
} |
|
||||
if (val.find_first_not_of("0123456789abcdefABCDEF") == string::npos) |
|
||||
{ |
|
||||
type.noteHexInput(val.size()); |
|
||||
return make_tuple(fromHex(val), type, Format::Hex); |
|
||||
} |
|
||||
if (val == "[") |
|
||||
return make_tuple(bytes(), type, Format::Open); |
|
||||
if (val == "]") |
|
||||
return make_tuple(bytes(), type, Format::Close); |
|
||||
type.noteBinaryInput(); |
|
||||
return make_tuple(asBytes(val), type, Format::Binary); |
|
||||
} |
|
||||
throw InvalidUserString(); |
|
||||
} |
|
||||
|
|
||||
struct ExpectedAdditionalParameter: public Exception {}; |
|
||||
struct ExpectedOpen: public Exception {}; |
|
||||
struct ExpectedClose: public Exception {}; |
|
||||
|
|
||||
struct ABIMethod |
|
||||
{ |
|
||||
string name; |
|
||||
vector<ABIType> ins; |
|
||||
vector<ABIType> outs; |
|
||||
bool isConstant = false; |
|
||||
|
|
||||
// isolation *IS* documentation.
|
|
||||
|
|
||||
ABIMethod() = default; |
|
||||
|
|
||||
ABIMethod(js::mObject _o) |
|
||||
{ |
|
||||
name = _o["name"].get_str(); |
|
||||
isConstant = _o["constant"].get_bool(); |
|
||||
if (_o.count("inputs")) |
|
||||
for (auto const& i: _o["inputs"].get_array()) |
|
||||
{ |
|
||||
js::mObject a = i.get_obj(); |
|
||||
ins.push_back(ABIType(a["type"].get_str(), a["name"].get_str())); |
|
||||
} |
|
||||
if (_o.count("outputs")) |
|
||||
for (auto const& i: _o["outputs"].get_array()) |
|
||||
{ |
|
||||
js::mObject a = i.get_obj(); |
|
||||
outs.push_back(ABIType(a["type"].get_str(), a["name"].get_str())); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
ABIMethod(string const& _name, vector<ABIType> const& _args) |
|
||||
{ |
|
||||
name = _name; |
|
||||
ins = _args; |
|
||||
} |
|
||||
|
|
||||
string sig() const |
|
||||
{ |
|
||||
string methodArgs; |
|
||||
for (auto const& arg: ins) |
|
||||
methodArgs += (methodArgs.empty() ? "" : ",") + arg.canon(); |
|
||||
return name + "(" + methodArgs + ")"; |
|
||||
} |
|
||||
FixedHash<4> id() const { return FixedHash<4>(sha3(sig())); } |
|
||||
|
|
||||
std::string solidityDeclaration() const |
|
||||
{ |
|
||||
ostringstream ss; |
|
||||
ss << "function " << name << "("; |
|
||||
int f = 0; |
|
||||
for (ABIType const& i: ins) |
|
||||
ss << (f++ ? ", " : "") << i.canon() << " " << i.name; |
|
||||
ss << ") "; |
|
||||
if (isConstant) |
|
||||
ss << "constant "; |
|
||||
if (!outs.empty()) |
|
||||
{ |
|
||||
ss << "returns("; |
|
||||
f = 0; |
|
||||
for (ABIType const& i: outs) |
|
||||
ss << (f++ ? ", " : "") << i.canon() << " " << i.name; |
|
||||
ss << ")"; |
|
||||
} |
|
||||
return ss.str(); |
|
||||
} |
|
||||
|
|
||||
bytes encode(vector<pair<bytes, Format>> const& _params) const |
|
||||
{ |
|
||||
bytes ret = name.empty() ? bytes() : id().asBytes(); |
|
||||
bytes suffix; |
|
||||
|
|
||||
// int int[] int
|
|
||||
// example: 42 [ 1 2 3 ] 69
|
|
||||
// int[2][][3]
|
|
||||
// example: [ [ [ 1 2 3 ] [ 4 5 6 ] ] [ ] ]
|
|
||||
|
|
||||
unsigned pi = 0; |
|
||||
|
|
||||
for (ABIType const& a: ins) |
|
||||
{ |
|
||||
if (pi >= _params.size()) |
|
||||
throw ExpectedAdditionalParameter(); |
|
||||
auto put = [&]() { |
|
||||
if (a.isBytes()) |
|
||||
ret += h256(u256(_params[pi].first.size())).asBytes(); |
|
||||
suffix += a.unrender(_params[pi].first, _params[pi].second); |
|
||||
pi++; |
|
||||
if (pi >= _params.size()) |
|
||||
throw ExpectedAdditionalParameter(); |
|
||||
}; |
|
||||
function<void(vector<int>, unsigned)> putDim = [&](vector<int> addr, unsigned q) { |
|
||||
if (addr.size() == a.dims.size()) |
|
||||
put(); |
|
||||
else |
|
||||
{ |
|
||||
if (_params[pi].second != Format::Open) |
|
||||
throw ExpectedOpen(); |
|
||||
++pi; |
|
||||
int l = a.dims[a.dims.size() - 1 - addr.size()]; |
|
||||
if (l == -1) |
|
||||
{ |
|
||||
// read ahead in params and discover the arity.
|
|
||||
unsigned depth = 0; |
|
||||
l = 0; |
|
||||
for (unsigned pi2 = pi; depth || _params[pi2].second != Format::Close;) |
|
||||
{ |
|
||||
if (_params[pi2].second == Format::Open) |
|
||||
++depth; |
|
||||
if (_params[pi2].second == Format::Close) |
|
||||
--depth; |
|
||||
if (!depth) |
|
||||
++l; |
|
||||
if (++pi2 == _params.size()) |
|
||||
throw ExpectedClose(); |
|
||||
} |
|
||||
ret += h256(u256(l)).asBytes(); |
|
||||
} |
|
||||
q *= l; |
|
||||
for (addr.push_back(0); addr.back() < l; ++addr.back()) |
|
||||
putDim(addr, q); |
|
||||
if (_params[pi].second != Format::Close) |
|
||||
throw ExpectedClose(); |
|
||||
++pi; |
|
||||
} |
|
||||
}; |
|
||||
putDim(vector<int>(), 1); |
|
||||
} |
|
||||
return ret + suffix; |
|
||||
} |
|
||||
string decode(bytes const& _data, int _index, EncodingPrefs _ep) |
|
||||
{ |
|
||||
stringstream out; |
|
||||
unsigned di = 0; |
|
||||
vector<unsigned> catDims; |
|
||||
for (ABIType const& a: outs) |
|
||||
{ |
|
||||
auto put = [&]() { |
|
||||
if (a.isBytes()) |
|
||||
{ |
|
||||
catDims.push_back(fromBigEndian<unsigned>(bytesConstRef(&_data).cropped(di, 32))); |
|
||||
di += 32; |
|
||||
} |
|
||||
}; |
|
||||
function<void(vector<int>, unsigned)> putDim = [&](vector<int> addr, unsigned q) { |
|
||||
if (addr.size() == a.dims.size()) |
|
||||
put(); |
|
||||
else |
|
||||
{ |
|
||||
int l = a.dims[a.dims.size() - 1 - addr.size()]; |
|
||||
if (l == -1) |
|
||||
{ |
|
||||
l = fromBigEndian<unsigned>(bytesConstRef(&_data).cropped(di, 32)); |
|
||||
catDims.push_back(l); |
|
||||
di += 32; |
|
||||
} |
|
||||
q *= l; |
|
||||
for (addr.push_back(0); addr.back() < l; ++addr.back()) |
|
||||
putDim(addr, q); |
|
||||
} |
|
||||
}; |
|
||||
putDim(vector<int>(), 1); |
|
||||
} |
|
||||
unsigned d = 0; |
|
||||
for (ABIType const& a: outs) |
|
||||
{ |
|
||||
if (_index == -1 && out.tellp() > 0) |
|
||||
out << ", "; |
|
||||
auto put = [&]() { |
|
||||
if (a.isBytes()) |
|
||||
{ |
|
||||
out << a.render(bytesConstRef(&_data).cropped(di, catDims[d]).toBytes(), _ep); |
|
||||
di += ((catDims[d] + 31) / 32) * 32; |
|
||||
d++; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
out << a.render(bytesConstRef(&_data).cropped(di, 32).toBytes(), _ep); |
|
||||
di += 32; |
|
||||
} |
|
||||
}; |
|
||||
function<void(vector<int>)> putDim = [&](vector<int> addr) { |
|
||||
if (addr.size() == a.dims.size()) |
|
||||
put(); |
|
||||
else |
|
||||
{ |
|
||||
out << "["; |
|
||||
addr.push_back(0); |
|
||||
int l = a.dims[a.dims.size() - 1 - (addr.size() - 1)]; |
|
||||
if (l == -1) |
|
||||
l = catDims[d++]; |
|
||||
for (addr.back() = 0; addr.back() < l; ++addr.back()) |
|
||||
{ |
|
||||
if (addr.back()) |
|
||||
out << ", "; |
|
||||
putDim(addr); |
|
||||
} |
|
||||
out << "]"; |
|
||||
} |
|
||||
}; |
|
||||
putDim(vector<int>()); |
|
||||
} |
|
||||
return out.str(); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
string canonSig(string const& _name, vector<ABIType> const& _args) |
|
||||
{ |
|
||||
try { |
|
||||
string methodArgs; |
|
||||
for (auto const& arg: _args) |
|
||||
methodArgs += (methodArgs.empty() ? "" : ",") + arg.canon(); |
|
||||
return _name + "(" + methodArgs + ")"; |
|
||||
} |
|
||||
catch (...) { |
|
||||
return string(); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
struct UnknownMethod: public Exception {}; |
|
||||
struct OverloadedMethod: public Exception {}; |
|
||||
|
|
||||
class ABI |
|
||||
{ |
|
||||
public: |
|
||||
ABI() = default; |
|
||||
ABI(std::string const& _json) |
|
||||
{ |
|
||||
js::mValue v; |
|
||||
js::read_string(_json, v); |
|
||||
for (auto const& i: v.get_array()) |
|
||||
{ |
|
||||
js::mObject o = i.get_obj(); |
|
||||
if (o["type"].get_str() != "function") |
|
||||
continue; |
|
||||
ABIMethod m(o); |
|
||||
m_methods[m.id()] = m; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
ABIMethod method(string _nameOrSig, vector<ABIType> const& _args) const |
|
||||
{ |
|
||||
auto id = FixedHash<4>(sha3(_nameOrSig)); |
|
||||
if (!m_methods.count(id)) |
|
||||
id = FixedHash<4>(sha3(canonSig(_nameOrSig, _args))); |
|
||||
if (!m_methods.count(id)) |
|
||||
for (auto const& m: m_methods) |
|
||||
if (m.second.name == _nameOrSig) |
|
||||
{ |
|
||||
if (m_methods.count(id)) |
|
||||
throw OverloadedMethod(); |
|
||||
id = m.first; |
|
||||
} |
|
||||
if (m_methods.count(id)) |
|
||||
return m_methods.at(id); |
|
||||
throw UnknownMethod(); |
|
||||
} |
|
||||
|
|
||||
friend ostream& operator<<(ostream& _out, ABI const& _abi); |
|
||||
|
|
||||
private: |
|
||||
map<FixedHash<4>, ABIMethod> m_methods; |
|
||||
}; |
|
||||
|
|
||||
ostream& operator<<(ostream& _out, ABI const& _abi) |
|
||||
{ |
|
||||
_out << "contract {" << endl; |
|
||||
for (auto const& i: _abi.m_methods) |
|
||||
_out << " " << i.second.solidityDeclaration() << "; // " << i.first.abridged() << endl; |
|
||||
_out << "}" << endl; |
|
||||
return _out; |
|
||||
} |
|
||||
|
|
||||
void userOutput(ostream& _out, bytes const& _data, Encoding _e) |
|
||||
{ |
|
||||
switch (_e) |
|
||||
{ |
|
||||
case Encoding::Binary: |
|
||||
_out.write((char const*)_data.data(), _data.size()); |
|
||||
break; |
|
||||
default: |
|
||||
_out << toHex(_data) << endl; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
template <unsigned n, class T> vector<typename std::remove_reference<decltype(get<n>(T()))>::type> retrieve(vector<T> const& _t) |
|
||||
{ |
|
||||
vector<typename std::remove_reference<decltype(get<n>(T()))>::type> ret; |
|
||||
for (T const& i: _t) |
|
||||
ret.push_back(get<n>(i)); |
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
int main(int argc, char** argv) |
|
||||
{ |
|
||||
Encoding encoding = Encoding::Auto; |
|
||||
Mode mode = Mode::Encode; |
|
||||
string abiFile; |
|
||||
string method; |
|
||||
Tristate formatPrefix = Tristate::Mu; |
|
||||
Tristate typePrefix = Tristate::Mu; |
|
||||
EncodingPrefs prefs; |
|
||||
bool verbose = false; |
|
||||
int outputIndex = -1; |
|
||||
vector<pair<bytes, Format>> params; |
|
||||
vector<ABIType> args; |
|
||||
string incoming; |
|
||||
|
|
||||
for (int i = 1; i < argc; ++i) |
|
||||
{ |
|
||||
string arg = argv[i]; |
|
||||
if (arg == "-h" || arg == "--help") |
|
||||
help(); |
|
||||
else if (arg == "enc" && i == 1) |
|
||||
mode = Mode::Encode; |
|
||||
else if (arg == "dec" && i == 1) |
|
||||
mode = Mode::Decode; |
|
||||
else if ((arg == "-a" || arg == "--abi") && argc > i) |
|
||||
abiFile = argv[++i]; |
|
||||
else if ((arg == "-i" || arg == "--index") && argc > i) |
|
||||
outputIndex = atoi(argv[++i]); |
|
||||
else if (arg == "-p" || arg == "--prefix") |
|
||||
prefs.prefix = true; |
|
||||
else if (arg == "-f" || arg == "--format-prefix") |
|
||||
formatPrefix = Tristate::True; |
|
||||
else if (arg == "-F" || arg == "--no-format-prefix") |
|
||||
formatPrefix = Tristate::False; |
|
||||
else if (arg == "-t" || arg == "--typing") |
|
||||
typePrefix = Tristate::True; |
|
||||
else if (arg == "-T" || arg == "--no-typing") |
|
||||
typePrefix = Tristate::False; |
|
||||
else if (arg == "-x" || arg == "--hex") |
|
||||
prefs.e = Encoding::Hex; |
|
||||
else if (arg == "-d" || arg == "--decimal" || arg == "--dec") |
|
||||
prefs.e = Encoding::Decimal; |
|
||||
else if (arg == "-b" || arg == "--binary" || arg == "--bin") |
|
||||
prefs.e = Encoding::Binary; |
|
||||
else if (arg == "-v" || arg == "--verbose") |
|
||||
verbose = true; |
|
||||
else if (arg == "-V" || arg == "--version") |
|
||||
version(); |
|
||||
else if (method.empty()) |
|
||||
method = arg; |
|
||||
else if (mode == Mode::Encode) |
|
||||
{ |
|
||||
auto u = fromUser(arg, formatPrefix, typePrefix); |
|
||||
args.push_back(get<1>(u)); |
|
||||
params.push_back(make_pair(get<0>(u), get<2>(u))); |
|
||||
} |
|
||||
else if (mode == Mode::Decode) |
|
||||
incoming += arg; |
|
||||
} |
|
||||
|
|
||||
string abiData; |
|
||||
if (!abiFile.empty()) |
|
||||
abiData = contentsString(abiFile); |
|
||||
|
|
||||
if (mode == Mode::Encode) |
|
||||
{ |
|
||||
ABIMethod m; |
|
||||
if (abiData.empty()) |
|
||||
m = ABIMethod(method, args); |
|
||||
else |
|
||||
{ |
|
||||
ABI abi(abiData); |
|
||||
if (verbose) |
|
||||
cerr << "ABI:" << endl << abi; |
|
||||
try { |
|
||||
m = abi.method(method, args); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Unknown method in ABI." << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
} |
|
||||
try { |
|
||||
userOutput(cout, m.encode(params), encoding); |
|
||||
} |
|
||||
catch (ExpectedAdditionalParameter const&) |
|
||||
{ |
|
||||
cerr << "Expected additional parameter in input." << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
catch (ExpectedOpen const&) |
|
||||
{ |
|
||||
cerr << "Expected open-bracket '[' in input." << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
catch (ExpectedClose const&) |
|
||||
{ |
|
||||
cerr << "Expected close-bracket ']' in input." << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
} |
|
||||
else if (mode == Mode::Decode) |
|
||||
{ |
|
||||
if (abiData.empty()) |
|
||||
{ |
|
||||
cerr << "Please specify an ABI file." << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
ABI abi(abiData); |
|
||||
ABIMethod m; |
|
||||
if (verbose) |
|
||||
cerr << "ABI:" << endl << abi; |
|
||||
try { |
|
||||
m = abi.method(method, args); |
|
||||
} |
|
||||
catch(...) |
|
||||
{ |
|
||||
cerr << "Unknown method in ABI." << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
string encoded; |
|
||||
if (incoming == "--" || incoming.empty()) |
|
||||
for (int i = cin.get(); i != -1; i = cin.get()) |
|
||||
encoded.push_back((char)i); |
|
||||
else |
|
||||
{ |
|
||||
encoded = contentsString(incoming); |
|
||||
} |
|
||||
cout << m.decode(fromHex(boost::trim_copy(encoded)), outputIndex, prefs) << endl; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
@ -1 +0,0 @@ |
|||||
add_custom_target(alethzero) |
|
||||
@ -1,33 +0,0 @@ |
|||||
cmake_policy(SET CMP0015 NEW) |
|
||||
set(CMAKE_AUTOMOC OFF) |
|
||||
|
|
||||
aux_source_directory(. SRC_LIST) |
|
||||
|
|
||||
include_directories(BEFORE ..) |
|
||||
include_directories(${Boost_INCLUDE_DIRS}) |
|
||||
include_directories(${JSON_RPC_CPP_INCLUDE_DIRS}) |
|
||||
|
|
||||
if (JSCONSOLE) |
|
||||
include_directories(${V8_INCLUDE_DIRS}) |
|
||||
endif() |
|
||||
|
|
||||
set(EXECUTABLE ethkey) |
|
||||
|
|
||||
file(GLOB HEADERS "*.h") |
|
||||
|
|
||||
add_executable(${EXECUTABLE} ${SRC_LIST} ${HEADERS}) |
|
||||
|
|
||||
add_dependencies(${EXECUTABLE} BuildInfo.h) |
|
||||
|
|
||||
target_link_libraries(${EXECUTABLE} devcrypto) |
|
||||
target_link_libraries(${EXECUTABLE} ethcore) |
|
||||
|
|
||||
if (DEFINED WIN32 AND NOT DEFINED CMAKE_COMPILER_IS_MINGW) |
|
||||
eth_copy_dlls("${EXECUTABLE}" MHD_DLLS) |
|
||||
endif() |
|
||||
|
|
||||
if (APPLE) |
|
||||
install(TARGETS ${EXECUTABLE} DESTINATION bin) |
|
||||
else() |
|
||||
eth_install_executable(${EXECUTABLE}) |
|
||||
endif() |
|
||||
@ -1,769 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
/*
|
|
||||
This file is part of cpp-ethereum. |
|
||||
|
|
||||
cpp-ethereum is free software: you can redistribute it and/or modify |
|
||||
it under the terms of the GNU General Public License as published by |
|
||||
the Free Software Foundation, either version 3 of the License, or |
|
||||
(at your option) any later version. |
|
||||
|
|
||||
cpp-ethereum is distributed in the hope that it will be useful, |
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||
GNU General Public License for more details. |
|
||||
|
|
||||
You should have received a copy of the GNU General Public License |
|
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
||||
*/ |
|
||||
/** @file KeyAux.cpp
|
|
||||
* @author Gav Wood <i@gavwood.com> |
|
||||
* @date 2014 |
|
||||
* CLI module for key management. |
|
||||
*/ |
|
||||
|
|
||||
#include <thread> |
|
||||
#include <chrono> |
|
||||
#include <fstream> |
|
||||
#include <iostream> |
|
||||
#include <boost/algorithm/string.hpp> |
|
||||
#include <boost/algorithm/string/trim_all.hpp> |
|
||||
#include <libdevcore/SHA3.h> |
|
||||
#include <libdevcore/FileSystem.h> |
|
||||
#include <libethcore/KeyManager.h> |
|
||||
#include <libethcore/ICAP.h> |
|
||||
#include <libethcore/Transaction.h> |
|
||||
#include <libdevcrypto/WordList.h> |
|
||||
#include "BuildInfo.h" |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
using namespace dev::eth; |
|
||||
using namespace boost::algorithm; |
|
||||
|
|
||||
#undef RETURN |
|
||||
|
|
||||
class BadArgument: public Exception {}; |
|
||||
|
|
||||
string getAccountPassword(KeyManager& keyManager, Address const& a) |
|
||||
{ |
|
||||
return getPassword("Enter password for address " + keyManager.accountName(a) + " (" + a.abridged() + "; hint:" + keyManager.passwordHint(a) + "): "); |
|
||||
} |
|
||||
|
|
||||
string createPassword(std::string const& _prompt) |
|
||||
{ |
|
||||
string ret; |
|
||||
while (true) |
|
||||
{ |
|
||||
ret = getPassword(_prompt); |
|
||||
string confirm = getPassword("Please confirm the password by entering it again: "); |
|
||||
if (ret == confirm) |
|
||||
break; |
|
||||
cout << "Passwords were different. Try again." << endl; |
|
||||
} |
|
||||
return ret; |
|
||||
// cout << "Enter a hint to help you remember this password: " << flush;
|
|
||||
// cin >> hint;
|
|
||||
// return make_pair(ret, hint);
|
|
||||
} |
|
||||
|
|
||||
pair<string, string> createPassword(KeyManager& _keyManager, std::string const& _prompt, std::string const& _pass = std::string(), std::string const& _hint = std::string()) |
|
||||
{ |
|
||||
string pass = _pass; |
|
||||
if (pass.empty()) |
|
||||
while (true) |
|
||||
{ |
|
||||
pass = getPassword(_prompt); |
|
||||
string confirm = getPassword("Please confirm the password by entering it again: "); |
|
||||
if (pass == confirm) |
|
||||
break; |
|
||||
cout << "Passwords were different. Try again." << endl; |
|
||||
} |
|
||||
string hint = _hint; |
|
||||
if (hint.empty() && !pass.empty() && !_keyManager.haveHint(pass)) |
|
||||
{ |
|
||||
cout << "Enter a hint to help you remember this password: " << flush; |
|
||||
getline(cin, hint); |
|
||||
} |
|
||||
return make_pair(pass, hint); |
|
||||
} |
|
||||
|
|
||||
class KeyCLI |
|
||||
{ |
|
||||
public: |
|
||||
enum class OperationMode |
|
||||
{ |
|
||||
None, |
|
||||
ListBare, |
|
||||
NewBare, |
|
||||
ImportBare, |
|
||||
ExportBare, |
|
||||
RecodeBare, |
|
||||
KillBare, |
|
||||
InspectBare, |
|
||||
CreateWallet, |
|
||||
List, |
|
||||
New, |
|
||||
Import, |
|
||||
ImportWithAddress, |
|
||||
ImportPresale, |
|
||||
Export, |
|
||||
Recode, |
|
||||
Kill, |
|
||||
NewBrain, |
|
||||
ImportBrain, |
|
||||
InspectBrain, |
|
||||
SignTx, |
|
||||
DecodeTx, |
|
||||
}; |
|
||||
|
|
||||
KeyCLI(OperationMode _mode = OperationMode::None): m_mode(_mode) {} |
|
||||
|
|
||||
bool interpretOption(int& i, int argc, char** argv) |
|
||||
{ |
|
||||
string arg = argv[i]; |
|
||||
if (arg == "--wallet-path" && i + 1 < argc) |
|
||||
m_walletPath = argv[++i]; |
|
||||
else if (arg == "--secrets-path" && i + 1 < argc) |
|
||||
m_secretsPath = argv[++i]; |
|
||||
else if ((arg == "-m" || arg == "--master") && i + 1 < argc) |
|
||||
m_masterPassword = argv[++i]; |
|
||||
else if (arg == "--unlock" && i + 1 < argc) |
|
||||
m_unlocks.push_back(argv[++i]); |
|
||||
else if (arg == "--lock" && i + 1 < argc) |
|
||||
m_lock = argv[++i]; |
|
||||
else if (arg == "--kdf" && i + 1 < argc) |
|
||||
m_kdf = argv[++i]; |
|
||||
else if (arg == "--kdf-param" && i + 2 < argc) |
|
||||
{ |
|
||||
auto n = argv[++i]; |
|
||||
auto v = argv[++i]; |
|
||||
m_kdfParams[n] = v; |
|
||||
} |
|
||||
else if (arg == "--sign-tx" && i + 1 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::SignTx; |
|
||||
m_signKey = argv[++i]; |
|
||||
} |
|
||||
else if (arg == "--tx-data" && i + 1 < argc) |
|
||||
try |
|
||||
{ |
|
||||
m_toSign.data = fromHex(argv[++i]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Invalid argument to " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else if (arg == "--tx-nonce" && i + 1 < argc) |
|
||||
try |
|
||||
{ |
|
||||
m_toSign.nonce = u256(argv[++i]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Invalid argument to " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else if ((arg == "--tx-dest" || arg == "--tx-to" || arg == "--tx-destination") && i + 1 < argc) |
|
||||
try |
|
||||
{ |
|
||||
m_toSign.creation = false; |
|
||||
m_toSign.to = toAddress(argv[++i]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Invalid argument to " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else if (arg == "--tx-gas" && i + 1 < argc) |
|
||||
try |
|
||||
{ |
|
||||
m_toSign.gas = u256(argv[++i]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Invalid argument to " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else if (arg == "--tx-gasprice" && i + 1 < argc) |
|
||||
try |
|
||||
{ |
|
||||
m_toSign.gasPrice = u256(argv[++i]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Invalid argument to " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else if (arg == "--tx-value" && i + 1 < argc) |
|
||||
try |
|
||||
{ |
|
||||
m_toSign.value = u256(argv[++i]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Invalid argument to " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
else if (arg == "--decode-tx") |
|
||||
m_mode = OperationMode::DecodeTx; |
|
||||
else if (arg == "--import-bare") |
|
||||
m_mode = OperationMode::ImportBare; |
|
||||
else if (arg == "--list-bare") |
|
||||
m_mode = OperationMode::ListBare; |
|
||||
else if (arg == "--export-bare") |
|
||||
m_mode = OperationMode::ExportBare; |
|
||||
else if (arg == "--inspect-bare") |
|
||||
m_mode = OperationMode::InspectBare; |
|
||||
else if (arg == "--recode-bare") |
|
||||
m_mode = OperationMode::RecodeBare; |
|
||||
else if (arg == "--kill-bare") |
|
||||
m_mode = OperationMode::KillBare; |
|
||||
else if (arg == "--create-wallet") |
|
||||
m_mode = OperationMode::CreateWallet; |
|
||||
else if (arg == "-l" || arg == "--list") |
|
||||
m_mode = OperationMode::List; |
|
||||
else if ((arg == "-n" || arg == "--new") && i + 1 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::New; |
|
||||
m_name = argv[++i]; |
|
||||
} |
|
||||
else if ((arg == "-i" || arg == "--import") && i + 2 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::Import; |
|
||||
m_inputs = strings(1, argv[++i]); |
|
||||
m_name = argv[++i]; |
|
||||
} |
|
||||
else if (arg == "--import-presale" && i + 2 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::ImportPresale; |
|
||||
m_inputs = strings(1, argv[++i]); |
|
||||
m_name = argv[++i]; |
|
||||
} |
|
||||
else if (arg == "--new-brain" && i + 1 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::NewBrain; |
|
||||
m_name = argv[++i]; |
|
||||
} |
|
||||
else if (arg == "--import-brain" && i + 1 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::ImportBrain; |
|
||||
m_name = argv[++i]; |
|
||||
} |
|
||||
else if (arg == "--inspect-brain") |
|
||||
m_mode = OperationMode::InspectBrain; |
|
||||
else if (arg == "--import-with-address" && i + 3 < argc) |
|
||||
{ |
|
||||
m_mode = OperationMode::ImportWithAddress; |
|
||||
m_inputs = strings(1, argv[++i]); |
|
||||
m_address = Address(argv[++i]); |
|
||||
m_name = argv[++i]; |
|
||||
} |
|
||||
else if (arg == "--export") |
|
||||
m_mode = OperationMode::Export; |
|
||||
else if (arg == "--recode") |
|
||||
m_mode = OperationMode::Recode; |
|
||||
else if (arg == "--no-icap") |
|
||||
m_icap = false; |
|
||||
else if (m_mode == OperationMode::DecodeTx || m_mode == OperationMode::SignTx || m_mode == OperationMode::ImportBare || m_mode == OperationMode::InspectBare || m_mode == OperationMode::KillBare || m_mode == OperationMode::Recode || m_mode == OperationMode::Export || m_mode == OperationMode::RecodeBare || m_mode == OperationMode::ExportBare) |
|
||||
m_inputs.push_back(arg); |
|
||||
else |
|
||||
return false; |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
KeyPair makeKey() const |
|
||||
{ |
|
||||
KeyPair k(Secret::random()); |
|
||||
while (m_icap && k.address()[0]) |
|
||||
k = KeyPair(Secret(sha3(k.secret().ref()))); |
|
||||
return k; |
|
||||
} |
|
||||
|
|
||||
Secret getSecret(std::string const& _signKey) |
|
||||
{ |
|
||||
string json = contentsString(_signKey); |
|
||||
if (!json.empty()) |
|
||||
return Secret(secretStore().secret(secretStore().readKeyContent(json), [&](){ return getPassword("Enter password for key: "); })); |
|
||||
else |
|
||||
{ |
|
||||
if (h128 u = fromUUID(_signKey)) |
|
||||
return Secret(secretStore().secret(u, [&](){ return getPassword("Enter password for key: "); })); |
|
||||
if (_signKey.substr(0, 6) == "brain#" && _signKey.find(":") != string::npos) |
|
||||
return KeyManager::subkey(KeyManager::brain(_signKey.substr(_signKey.find(":"))), stoul(_signKey.substr(6, _signKey.find(":") - 7))); |
|
||||
if (_signKey.substr(0, 6) == "brain:") |
|
||||
return KeyManager::brain(_signKey.substr(6)); |
|
||||
if (_signKey == "brain") |
|
||||
return KeyManager::brain(getPassword("Enter brain wallet phrase: ")); |
|
||||
Address a; |
|
||||
DEV_IGNORE_EXCEPTIONS(a = Address(_signKey)); |
|
||||
if (a) |
|
||||
return keyManager().secret(a, [&](){ return getPassword("Enter password for key (hint:" + keyManager().passwordHint(a) + "): "); }); |
|
||||
cerr << "Bad file, UUID and address: " << _signKey << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
void execute() |
|
||||
{ |
|
||||
switch (m_mode) |
|
||||
{ |
|
||||
case OperationMode::CreateWallet: |
|
||||
{ |
|
||||
KeyManager wallet(m_walletPath, m_secretsPath); |
|
||||
if (m_masterPassword.empty()) |
|
||||
m_masterPassword = createPassword("Please enter a MASTER password to protect your key store (make it strong!): "); |
|
||||
if (m_masterPassword.empty()) |
|
||||
cerr << "Aborted (empty password not allowed)." << endl; |
|
||||
else |
|
||||
{ |
|
||||
try |
|
||||
{ |
|
||||
wallet.create(m_masterPassword); |
|
||||
} |
|
||||
catch (Exception const& _e) |
|
||||
{ |
|
||||
cerr << "unable to create wallet" << endl << boost::diagnostic_information(_e); |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::DecodeTx: |
|
||||
{ |
|
||||
bytes b = inputData(m_inputs[0]); |
|
||||
if (b.empty()) |
|
||||
cerr << "Unknown file or bad hex: '" << m_inputs[0] << "'" << endl; |
|
||||
else |
|
||||
try |
|
||||
{ |
|
||||
TransactionBase t(b, CheckTransaction::None); |
|
||||
cout << "Transaction " << t.sha3().hex() << endl; |
|
||||
if (t.isCreation()) |
|
||||
{ |
|
||||
cout << " type: creation" << endl; |
|
||||
cout << " code: " << toHex(t.data()) << endl; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
cout << " type: message" << endl; |
|
||||
cout << " to: " << t.to().hex() << endl; |
|
||||
cout << " data: " << (t.data().empty() ? "none" : toHex(t.data())) << endl; |
|
||||
} |
|
||||
try |
|
||||
{ |
|
||||
auto s = t.sender(); |
|
||||
if (t.isCreation()) |
|
||||
cout << " creates: " << toAddress(s, t.nonce()).hex() << endl; |
|
||||
cout << " from: " << s.hex() << endl; |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cout << " from: <unsigned>" << endl; |
|
||||
} |
|
||||
cout << " value: " << formatBalance(t.value()) << " (" << t.value() << " wei)" << endl; |
|
||||
cout << " nonce: " << t.nonce() << endl; |
|
||||
cout << " gas: " << t.gas() << endl; |
|
||||
cout << " gas price: " << formatBalance(t.gasPrice()) << " (" << t.gasPrice() << " wei)" << endl; |
|
||||
cout << " signing hash: " << t.sha3(WithoutSignature).hex() << endl; |
|
||||
cout << " v: " << (int)t.signature().v << endl; |
|
||||
cout << " r: " << t.signature().r << endl; |
|
||||
cout << " s: " << t.signature().s << endl; |
|
||||
} |
|
||||
catch (Exception& ex) |
|
||||
{ |
|
||||
cerr << "Invalid transaction: " << ex.what() << endl; |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::SignTx: |
|
||||
{ |
|
||||
Secret s = getSecret(m_signKey); |
|
||||
if (m_inputs.empty()) |
|
||||
m_inputs.push_back(string()); |
|
||||
for (string const& i: m_inputs) |
|
||||
{ |
|
||||
bool isFile = false; |
|
||||
try |
|
||||
{ |
|
||||
TransactionBase t = i.empty() ? TransactionBase(m_toSign) : TransactionBase(inputData(i, &isFile), CheckTransaction::None); |
|
||||
t.sign(s); |
|
||||
cout << t.sha3() << ": "; |
|
||||
if (isFile) |
|
||||
{ |
|
||||
writeFile(i + ".signed", toHex(t.rlp())); |
|
||||
cout << i + ".signed" << endl; |
|
||||
} |
|
||||
else |
|
||||
cout << toHex(t.rlp()) << endl; |
|
||||
} |
|
||||
catch (Exception& ex) |
|
||||
{ |
|
||||
cerr << "Invalid transaction: " << ex.what() << endl; |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::NewBrain: |
|
||||
{ |
|
||||
if (m_name != "--") |
|
||||
keyManager(); |
|
||||
boost::random_device d; |
|
||||
boost::random::uniform_int_distribution<unsigned> pickWord(0, WordList.size() - 1); |
|
||||
string seed; |
|
||||
for (int i = 0; i < 13; ++i) |
|
||||
seed += (seed.size() ? " " : "") + WordList[pickWord(d)]; |
|
||||
cout << "Your brain key phrase: <<" << seed << ">>" << endl; |
|
||||
if (m_name != "--") |
|
||||
{ |
|
||||
std::string hint; |
|
||||
cout << "Enter a hint for the phrase if you want: " << flush; |
|
||||
getline(cin, hint); |
|
||||
Address a = keyManager().importBrain(seed, m_name, hint); |
|
||||
cout << a.abridged() << endl; |
|
||||
cout << " ICAP: " << ICAP(a).encoded() << endl; |
|
||||
cout << " Address: " << a.hex() << endl; |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::InspectBrain: |
|
||||
{ |
|
||||
Address a = toAddress(KeyManager::brain(getPassword("Enter brain wallet key phrase: "))); |
|
||||
cout << a.abridged() << endl; |
|
||||
cout << " ICAP: " << ICAP(a).encoded() << endl; |
|
||||
cout << " Address: " << a.hex() << endl; |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::ListBare: |
|
||||
for (h128 const& u: std::set<h128>() + secretStore().keys()) |
|
||||
cout << toUUID(u) << endl; |
|
||||
break; |
|
||||
case OperationMode::NewBare: |
|
||||
{ |
|
||||
if (m_lock.empty()) |
|
||||
m_lock = createPassword("Enter a password with which to secure this account: "); |
|
||||
auto k = makeKey(); |
|
||||
h128 u = secretStore().importSecret(k.secret().ref(), m_lock); |
|
||||
cout << "Created key " << toUUID(u) << endl; |
|
||||
cout << " Address: " << k.address().hex() << endl; |
|
||||
cout << " ICAP: " << ICAP(k.address()).encoded() << endl; |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::ImportBare: |
|
||||
for (string const& input: m_inputs) |
|
||||
{ |
|
||||
h128 u; |
|
||||
bytesSec b; |
|
||||
b.writable() = fromHex(input); |
|
||||
if (b.size() != 32) |
|
||||
{ |
|
||||
std::string s = contentsString(input); |
|
||||
b.writable() = fromHex(s); |
|
||||
if (b.size() != 32) |
|
||||
u = secretStore().importKey(input); |
|
||||
} |
|
||||
if (!u && b.size() == 32) |
|
||||
u = secretStore().importSecret(b, lockPassword(toAddress(Secret(b)).abridged())); |
|
||||
if (!u) |
|
||||
{ |
|
||||
cerr << "Cannot import " << input << " not a file or secret." << endl; |
|
||||
continue; |
|
||||
} |
|
||||
cout << "Successfully imported " << input << " as " << toUUID(u); |
|
||||
} |
|
||||
break; |
|
||||
case OperationMode::InspectBare: |
|
||||
for (auto const& i: m_inputs) |
|
||||
if (!contents(i).empty()) |
|
||||
{ |
|
||||
h128 u = secretStore().readKey(i, false); |
|
||||
bytesSec s = secretStore().secret(u, [&](){ return getPassword("Enter password for key " + i + ": "); }); |
|
||||
cout << "Key " << i << ":" << endl; |
|
||||
cout << " UUID: " << toUUID(u) << ":" << endl; |
|
||||
cout << " Address: " << toAddress(Secret(s)).hex() << endl; |
|
||||
cout << " Secret: " << toHex(s.ref().cropped(0, 8)) << "..." << endl; |
|
||||
} |
|
||||
else if (h128 u = fromUUID(i)) |
|
||||
{ |
|
||||
bytesSec s = secretStore().secret(u, [&](){ return getPassword("Enter password for key " + toUUID(u) + ": "); }); |
|
||||
cout << "Key " << i << ":" << endl; |
|
||||
cout << " Address: " << toAddress(Secret(s)).hex() << endl; |
|
||||
cout << " Secret: " << toHex(s.ref().cropped(0, 8)) << "..." << endl; |
|
||||
} |
|
||||
else |
|
||||
cerr << "Couldn't inspect " << i << "; not found." << endl; |
|
||||
break; |
|
||||
case OperationMode::ExportBare: break; |
|
||||
case OperationMode::RecodeBare: |
|
||||
for (auto const& i: m_inputs) |
|
||||
if (h128 u = fromUUID(i)) |
|
||||
if (secretStore().recode(u, lockPassword(toUUID(u)), [&](){ return getPassword("Enter password for key " + toUUID(u) + ": "); }, kdf())) |
|
||||
cerr << "Re-encoded " << toUUID(u) << endl; |
|
||||
else |
|
||||
cerr << "Couldn't re-encode " << toUUID(u) << "; key corrupt or incorrect password supplied." << endl; |
|
||||
else |
|
||||
cerr << "Couldn't re-encode " << i << "; not found." << endl; |
|
||||
break; |
|
||||
case OperationMode::KillBare: |
|
||||
for (auto const& i: m_inputs) |
|
||||
if (h128 u = fromUUID(i)) |
|
||||
secretStore().kill(u); |
|
||||
else |
|
||||
cerr << "Couldn't kill " << i << "; not found." << endl; |
|
||||
break; |
|
||||
case OperationMode::New: |
|
||||
{ |
|
||||
keyManager(); |
|
||||
tie(m_lock, m_lockHint) = createPassword(keyManager(), "Enter a password with which to secure this account (or nothing to use the master password): ", m_lock, m_lockHint); |
|
||||
auto k = makeKey(); |
|
||||
bool usesMaster = m_lock.empty(); |
|
||||
h128 u = usesMaster ? keyManager().import(k.secret(), m_name) : keyManager().import(k.secret(), m_name, m_lock, m_lockHint); |
|
||||
cout << "Created key " << toUUID(u) << endl; |
|
||||
cout << " Name: " << m_name << endl; |
|
||||
if (usesMaster) |
|
||||
cout << " Uses master password." << endl; |
|
||||
else |
|
||||
cout << " Password hint: " << m_lockHint << endl; |
|
||||
cout << " Address: " << k.address().hex() << endl; |
|
||||
cout << " ICAP: " << ICAP(k.address()).encoded() << endl; |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::ImportWithAddress: |
|
||||
{ |
|
||||
keyManager(); |
|
||||
string const& i = m_inputs[0]; |
|
||||
h128 u; |
|
||||
bytesSec b; |
|
||||
b.writable() = fromHex(i); |
|
||||
if (b.size() != 32) |
|
||||
{ |
|
||||
std::string s = contentsString(i); |
|
||||
b.writable() = fromHex(s); |
|
||||
if (b.size() != 32) |
|
||||
u = keyManager().store().importKey(i); |
|
||||
} |
|
||||
if (!u && b.size() == 32) |
|
||||
u = keyManager().store().importSecret(b, lockPassword(toAddress(Secret(b)).abridged())); |
|
||||
if (!u) |
|
||||
{ |
|
||||
cerr << "Cannot import " << i << " not a file or secret." << endl; |
|
||||
break; |
|
||||
} |
|
||||
keyManager().importExisting(u, m_name, m_address); |
|
||||
cout << "Successfully imported " << i << ":" << endl; |
|
||||
cout << " Name: " << m_name << endl; |
|
||||
cout << " Address: " << m_address << endl; |
|
||||
cout << " UUID: " << toUUID(u) << endl; |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::ImportBrain: |
|
||||
{ |
|
||||
keyManager(); |
|
||||
std::string seed = getPassword("Enter brain wallet key phrase: "); |
|
||||
std::string hint; |
|
||||
cout << "Enter a hint for the phrase if you want: " << flush; |
|
||||
getline(cin, hint); |
|
||||
Address a = keyManager().importBrain(seed, m_name, hint); |
|
||||
cout << a << endl; |
|
||||
cout << " ICAP: " << ICAP(a).encoded() << endl; |
|
||||
cout << " Address: " << a.hex() << endl; |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::ImportPresale: |
|
||||
{ |
|
||||
keyManager(); |
|
||||
std::string pw; |
|
||||
KeyPair k = keyManager().presaleSecret(contentsString(m_inputs[0]), [&](bool){ return (pw = getPassword("Enter the password for the presale key: ")); }); |
|
||||
keyManager().import(k.secret(), m_name, pw, "Same password as used for presale key"); |
|
||||
break; |
|
||||
} |
|
||||
case OperationMode::List: |
|
||||
{ |
|
||||
vector<u128> bare; |
|
||||
AddressHash got; |
|
||||
|
|
||||
for (auto const& u: keyManager().store().keys()) |
|
||||
if (Address a = keyManager().address(u)) |
|
||||
{ |
|
||||
got.insert(a); |
|
||||
cout << toUUID(u) << " " << a.abridged(); |
|
||||
string s = ICAP(a).encoded(); |
|
||||
cout << " " << s << string(35 - s.size(), ' '); |
|
||||
cout << " " << keyManager().accountName(a) << endl; |
|
||||
} |
|
||||
else |
|
||||
bare.push_back(u); |
|
||||
for (auto const& a: keyManager().accounts()) |
|
||||
if (!got.count(a)) |
|
||||
{ |
|
||||
cout << " (Brain) " << a.abridged(); |
|
||||
cout << " " << ICAP(a).encoded() << " "; |
|
||||
cout << " " << keyManager().accountName(a) << endl; |
|
||||
} |
|
||||
for (auto const& u: bare) |
|
||||
cout << toUUID(u) << " (Bare)" << endl; |
|
||||
} |
|
||||
default: break; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
std::string lockPassword(std::string const& _accountName) |
|
||||
{ |
|
||||
return m_lock.empty() ? createPassword("Enter a password with which to secure account " + _accountName + ": ") : m_lock; |
|
||||
} |
|
||||
|
|
||||
static void streamHelp(ostream& _out) |
|
||||
{ |
|
||||
_out |
|
||||
<< "Secret-store (\"bare\") operation modes:" << endl |
|
||||
<< " --list-bare List all secret available in secret-store." << endl |
|
||||
<< " --new-bare Generate and output a key without interacting with wallet and dump the JSON." << endl |
|
||||
<< " --import-bare [ <file>|<secret-hex> , ... ] Import keys from given sources." << endl |
|
||||
<< " --recode-bare [ <uuid>|<file> , ... ] Decrypt and re-encrypt given keys." << endl |
|
||||
<< " --inspect-bare [ <uuid>|<file> , ... ] Output information on given keys." << endl |
|
||||
// << " --export-bare [ <uuid> , ... ] Export given keys." << endl
|
|
||||
<< " --kill-bare [ <uuid> , ... ] Delete given keys." << endl |
|
||||
<< "Secret-store configuration:" << endl |
|
||||
<< " --secrets-path <path> Specify Web3 secret-store path (default: " << SecretStore::defaultPath() << ")" << endl |
|
||||
<< endl |
|
||||
<< "Wallet operating modes:" << endl |
|
||||
<< " -l,--list List all keys available in wallet." << endl |
|
||||
<< " -n,--new <name> Create a new key with given name and add it in the wallet." << endl |
|
||||
<< " -i,--import [<uuid>|<file>|<secret-hex>] <name> Import keys from given source and place in wallet." << endl |
|
||||
<< " --import-presale <file> <name> Import a presale wallet into a key with the given name." << endl |
|
||||
<< " --import-with-address [<uuid>|<file>|<secret-hex>] <address> <name> Import keys from given source with given address and place in wallet." << endl |
|
||||
<< " -e,--export [ <address>|<uuid> , ... ] Export given keys." << endl |
|
||||
<< " -r,--recode [ <address>|<uuid>|<file> , ... ] Decrypt and re-encrypt given keys." << endl |
|
||||
<< "Brain wallet operating modes:" << endl |
|
||||
<< "WARNING: Brain wallets with human-generated passphrasses are highly susceptible to attack. Don't use such a thing for" << endl |
|
||||
<< "anything important." << endl |
|
||||
<< " --new-brain [ <name>|-- ] Create a new 13-word brain wallet; argument is the name or if --, do not add to wallet."<< endl |
|
||||
<< " --import-brain <name> Import your own brain wallet." << endl |
|
||||
<< " --inspect-brain Check the address of a particular brain wallet." << endl |
|
||||
<< "Wallet configuration:" << endl |
|
||||
<< " --create-wallet Create an Ethereum master wallet." << endl |
|
||||
<< " --wallet-path <path> Specify Ethereum wallet path (default: " << KeyManager::defaultPath() << ")" << endl |
|
||||
<< " -m, --master <password> Specify wallet (master) password." << endl |
|
||||
<< endl |
|
||||
<< "Transaction operating modes:" << endl |
|
||||
<< " -d,--decode-tx [<hex>|<file>] Decode given transaction." << endl |
|
||||
<< " -s,--sign-tx [ <address>|<uuid>|<file>|brain((#<HD-index>):<brain-phrase>) ] [ <hex>|<file> , ... ] (Re-)Sign given transaction." << endl |
|
||||
<< endl |
|
||||
<< "Encryption configuration:" << endl |
|
||||
<< " --kdf <kdfname> Specify KDF to use when encrypting (default: sc rypt)" << endl |
|
||||
<< " --kdf-param <name> <value> Specify a parameter for the KDF." << endl |
|
||||
// << " --cipher <ciphername> Specify cipher to use when encrypting (default: aes-128-ctr)" << endl
|
|
||||
// << " --cipher-param <name> <value> Specify a parameter for the cipher." << endl
|
|
||||
<< " --lock <password> Specify password for when encrypting a (the) key." << endl |
|
||||
<< " --hint <hint> Specify hint for the --lock password." << endl |
|
||||
<< endl |
|
||||
<< "Decryption configuration:" << endl |
|
||||
<< " --unlock <password> Specify password for a (the) key." << endl |
|
||||
<< "Key generation configuration:" << endl |
|
||||
<< " --no-icap Don't bother to make a direct-ICAP capable key." << endl |
|
||||
; |
|
||||
} |
|
||||
|
|
||||
static bytes inputData(std::string const& _input, bool* _isFile = nullptr) |
|
||||
{ |
|
||||
bytes b = fromHex(_input); |
|
||||
if (_isFile) |
|
||||
*_isFile = false; |
|
||||
if (b.empty()) |
|
||||
{ |
|
||||
if (_isFile) |
|
||||
*_isFile = true; |
|
||||
std::string s = boost::trim_copy_if(contentsString(_input), is_any_of(" \t\n")); |
|
||||
b = fromHex(s); |
|
||||
if (b.empty()) |
|
||||
b = asBytes(s); |
|
||||
} |
|
||||
return b; |
|
||||
} |
|
||||
|
|
||||
static bool isTrue(std::string const& _m) |
|
||||
{ |
|
||||
return _m == "on" || _m == "yes" || _m == "true" || _m == "1"; |
|
||||
} |
|
||||
|
|
||||
static bool isFalse(std::string const& _m) |
|
||||
{ |
|
||||
return _m == "off" || _m == "no" || _m == "false" || _m == "0"; |
|
||||
} |
|
||||
|
|
||||
private: |
|
||||
void openWallet(KeyManager& _w) |
|
||||
{ |
|
||||
while (true) |
|
||||
{ |
|
||||
if (_w.load(m_masterPassword)) |
|
||||
break; |
|
||||
if (!m_masterPassword.empty()) |
|
||||
{ |
|
||||
cout << "Password invalid. Try again." << endl; |
|
||||
m_masterPassword.clear(); |
|
||||
} |
|
||||
m_masterPassword = getPassword("Please enter your MASTER password: "); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
KDF kdf() const { return m_kdf == "pbkdf2" ? KDF::PBKDF2_SHA256 : KDF::Scrypt; } |
|
||||
|
|
||||
KeyManager& keyManager() |
|
||||
{ |
|
||||
if (!m_keyManager) |
|
||||
{ |
|
||||
m_keyManager.reset(new KeyManager(m_walletPath, m_secretsPath)); |
|
||||
if (m_keyManager->exists()) |
|
||||
openWallet(*m_keyManager); |
|
||||
else |
|
||||
{ |
|
||||
cerr << "Couldn't open wallet. Does it exist?" << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
} |
|
||||
return *m_keyManager; |
|
||||
} |
|
||||
|
|
||||
SecretStore& secretStore() |
|
||||
{ |
|
||||
if (m_keyManager) |
|
||||
return m_keyManager->store(); |
|
||||
if (!m_secretStore) |
|
||||
m_secretStore.reset(new SecretStore(m_secretsPath)); |
|
||||
return *m_secretStore; |
|
||||
} |
|
||||
|
|
||||
/// Where the keys are.
|
|
||||
unique_ptr<SecretStore> m_secretStore; |
|
||||
unique_ptr<KeyManager> m_keyManager; |
|
||||
|
|
||||
/// Operating mode.
|
|
||||
OperationMode m_mode; |
|
||||
|
|
||||
/// Wallet stuff
|
|
||||
string m_secretsPath = SecretStore::defaultPath(); |
|
||||
string m_walletPath = KeyManager::defaultPath(); |
|
||||
|
|
||||
/// Wallet password stuff
|
|
||||
string m_masterPassword; |
|
||||
strings m_unlocks; |
|
||||
string m_lock; |
|
||||
string m_lockHint; |
|
||||
bool m_icap = true; |
|
||||
|
|
||||
/// Creating/importing
|
|
||||
string m_name; |
|
||||
Address m_address; |
|
||||
|
|
||||
/// Importing
|
|
||||
strings m_inputs; |
|
||||
|
|
||||
/// Signing
|
|
||||
string m_signKey; |
|
||||
TransactionSkeleton m_toSign; |
|
||||
|
|
||||
string m_kdf = "scrypt"; |
|
||||
map<string, string> m_kdfParams; |
|
||||
// string m_cipher;
|
|
||||
// map<string, string> m_cipherParams;
|
|
||||
}; |
|
||||
@ -1,84 +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 <http://www.gnu.org/licenses/>.
|
|
||||
*/ |
|
||||
/** @file main.cpp
|
|
||||
* @author Gav Wood <i@gavwood.com> |
|
||||
* @date 2014 |
|
||||
* Ethereum client. |
|
||||
*/ |
|
||||
|
|
||||
#include <thread> |
|
||||
#include <chrono> |
|
||||
#include <fstream> |
|
||||
#include <iostream> |
|
||||
#include <libdevcore/FileSystem.h> |
|
||||
#include <libdevcore/Log.h> |
|
||||
#include <libethcore/KeyManager.h> |
|
||||
#include "BuildInfo.h" |
|
||||
#include "KeyAux.h" |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
using namespace dev::eth; |
|
||||
|
|
||||
void help() |
|
||||
{ |
|
||||
cout |
|
||||
<< "Usage ethkey [OPTIONS]" << endl |
|
||||
<< "Options:" << endl << endl; |
|
||||
KeyCLI::streamHelp(cout); |
|
||||
cout |
|
||||
<< "General Options:" << endl |
|
||||
<< " -v,--verbosity <0 - 9> Set the log verbosity from 0 to 9 (default: 8)." << endl |
|
||||
<< " -V,--version Show the version and exit." << endl |
|
||||
<< " -h,--help Show this help message and exit." << endl |
|
||||
; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
void version() |
|
||||
{ |
|
||||
cout << "ethkey version " << dev::Version << endl; |
|
||||
cout << "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
int main(int argc, char** argv) |
|
||||
{ |
|
||||
KeyCLI m(KeyCLI::OperationMode::ListBare); |
|
||||
g_logVerbosity = 0; |
|
||||
|
|
||||
for (int i = 1; i < argc; ++i) |
|
||||
{ |
|
||||
string arg = argv[i]; |
|
||||
if (m.interpretOption(i, argc, argv)) {} |
|
||||
else if ((arg == "-v" || arg == "--verbosity") && i + 1 < argc) |
|
||||
g_logVerbosity = atoi(argv[++i]); |
|
||||
else if (arg == "-h" || arg == "--help") |
|
||||
help(); |
|
||||
else if (arg == "-V" || arg == "--version") |
|
||||
version(); |
|
||||
else |
|
||||
{ |
|
||||
cerr << "Invalid argument: " << arg << endl; |
|
||||
exit(-1); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
m.execute(); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
@ -1,19 +0,0 @@ |
|||||
cmake_policy(SET CMP0015 NEW) |
|
||||
set(CMAKE_AUTOMOC OFF) |
|
||||
|
|
||||
aux_source_directory(. SRC_LIST) |
|
||||
|
|
||||
include_directories(BEFORE ..) |
|
||||
include_directories(${DB_INCLUDE_DIRS}) |
|
||||
|
|
||||
set(EXECUTABLE ethvm) |
|
||||
|
|
||||
add_executable(${EXECUTABLE} ${SRC_LIST}) |
|
||||
|
|
||||
target_link_libraries(${EXECUTABLE} ethereum) |
|
||||
|
|
||||
if (APPLE) |
|
||||
install(TARGETS ${EXECUTABLE} DESTINATION bin) |
|
||||
else() |
|
||||
eth_install_executable(${EXECUTABLE}) |
|
||||
endif() |
|
||||
@ -1,224 +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 <http://www.gnu.org/licenses/>.
|
|
||||
*/ |
|
||||
/** @file main.cpp
|
|
||||
* @author Gav Wood <i@gavwood.com> |
|
||||
* @date 2014 |
|
||||
* EVM Execution tool. |
|
||||
*/ |
|
||||
#include <fstream> |
|
||||
#include <iostream> |
|
||||
#include <ctime> |
|
||||
#include <boost/algorithm/string.hpp> |
|
||||
#include <libdevcore/CommonIO.h> |
|
||||
#include <libdevcore/RLP.h> |
|
||||
#include <libdevcore/SHA3.h> |
|
||||
#include <libethereum/Block.h> |
|
||||
#include <libethereum/Executive.h> |
|
||||
#include <libevm/VM.h> |
|
||||
#include <libevm/VMFactory.h> |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
using namespace eth; |
|
||||
|
|
||||
void help() |
|
||||
{ |
|
||||
cout |
|
||||
<< "Usage ethvm <options> [trace|stats|output] (<file>|--)" << endl |
|
||||
<< "Transaction options:" << endl |
|
||||
<< " --value <n> Transaction should transfer the <n> wei (default: 0)." << endl |
|
||||
<< " --gas <n> Transaction should be given <n> gas (default: block gas limit)." << endl |
|
||||
<< " --gas-price <n> Transaction's gas price' should be <n> (default: 0)." << endl |
|
||||
<< " --sender <a> Transaction sender should be <a> (default: 0000...0069)." << endl |
|
||||
<< " --origin <a> Transaction origin should be <a> (default: 0000...0069)." << endl |
|
||||
#if ETH_EVMJIT || !ETH_TRUE |
|
||||
<< endl |
|
||||
<< "VM options:" << endl |
|
||||
<< " --vm <vm-kind> Select VM. Options are: interpreter, jit, smart. (default: interpreter)" << endl |
|
||||
#endif |
|
||||
<< endl |
|
||||
<< "Options for trace:" << endl |
|
||||
<< " --flat Minimal whitespace in the JSON." << endl |
|
||||
<< " --mnemonics Show instruction mnemonics in the trace (non-standard)." << endl |
|
||||
<< endl |
|
||||
<< "General options:" << endl |
|
||||
<< " -V,--version Show the version and exit." << endl |
|
||||
<< " -h,--help Show this help message and exit." << endl; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
void version() |
|
||||
{ |
|
||||
cout << "ethvm version " << dev::Version << endl; |
|
||||
cout << "By Gav Wood, 2015." << endl; |
|
||||
cout << "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
enum class Mode |
|
||||
{ |
|
||||
Trace, |
|
||||
Statistics, |
|
||||
OutputOnly |
|
||||
}; |
|
||||
|
|
||||
int main(int argc, char** argv) |
|
||||
{ |
|
||||
string incoming = "--"; |
|
||||
|
|
||||
Mode mode = Mode::Statistics; |
|
||||
State state; |
|
||||
Address sender = Address(69); |
|
||||
Address origin = Address(69); |
|
||||
u256 value = 0; |
|
||||
u256 gas = Block().gasLimitRemaining(); |
|
||||
u256 gasPrice = 0; |
|
||||
bool styledJson = true; |
|
||||
StandardTrace st; |
|
||||
EnvInfo envInfo; |
|
||||
|
|
||||
for (int i = 1; i < argc; ++i) |
|
||||
{ |
|
||||
string arg = argv[i]; |
|
||||
if (arg == "-h" || arg == "--help") |
|
||||
help(); |
|
||||
else if (arg == "-V" || arg == "--version") |
|
||||
version(); |
|
||||
#if ETH_EVMJIT |
|
||||
else if (arg == "--vm" && i + 1 < argc) |
|
||||
{ |
|
||||
string vmKind = argv[++i]; |
|
||||
if (vmKind == "interpreter") |
|
||||
VMFactory::setKind(VMKind::Interpreter); |
|
||||
else if (vmKind == "jit") |
|
||||
VMFactory::setKind(VMKind::JIT); |
|
||||
else if (vmKind == "smart") |
|
||||
VMFactory::setKind(VMKind::Smart); |
|
||||
else |
|
||||
{ |
|
||||
cerr << "Unknown VM kind: " << vmKind << endl; |
|
||||
return -1; |
|
||||
} |
|
||||
} |
|
||||
#endif |
|
||||
else if (arg == "--mnemonics") |
|
||||
st.setShowMnemonics(); |
|
||||
else if (arg == "--flat") |
|
||||
styledJson = false; |
|
||||
else if (arg == "--value" && i + 1 < argc) |
|
||||
value = u256(argv[++i]); |
|
||||
else if (arg == "--sender" && i + 1 < argc) |
|
||||
sender = Address(argv[++i]); |
|
||||
else if (arg == "--origin" && i + 1 < argc) |
|
||||
origin = Address(argv[++i]); |
|
||||
else if (arg == "--gas" && i + 1 < argc) |
|
||||
gas = u256(argv[++i]); |
|
||||
else if (arg == "--gas-price" && i + 1 < argc) |
|
||||
gasPrice = u256(argv[++i]); |
|
||||
else if (arg == "--value" && i + 1 < argc) |
|
||||
value = u256(argv[++i]); |
|
||||
else if (arg == "--value" && i + 1 < argc) |
|
||||
value = u256(argv[++i]); |
|
||||
else if (arg == "--beneficiary" && i + 1 < argc) |
|
||||
envInfo.setBeneficiary(Address(argv[++i])); |
|
||||
else if (arg == "--number" && i + 1 < argc) |
|
||||
envInfo.setNumber(u256(argv[++i])); |
|
||||
else if (arg == "--difficulty" && i + 1 < argc) |
|
||||
envInfo.setDifficulty(u256(argv[++i])); |
|
||||
else if (arg == "--timestamp" && i + 1 < argc) |
|
||||
envInfo.setTimestamp(u256(argv[++i])); |
|
||||
else if (arg == "--gas-limit" && i + 1 < argc) |
|
||||
envInfo.setGasLimit(u256(argv[++i])); |
|
||||
else if (arg == "--value" && i + 1 < argc) |
|
||||
value = u256(argv[++i]); |
|
||||
else if (arg == "stats") |
|
||||
mode = Mode::Statistics; |
|
||||
else if (arg == "output") |
|
||||
mode = Mode::OutputOnly; |
|
||||
else if (arg == "trace") |
|
||||
mode = Mode::Trace; |
|
||||
else |
|
||||
incoming = arg; |
|
||||
} |
|
||||
|
|
||||
bytes code; |
|
||||
if (incoming == "--" || incoming.empty()) |
|
||||
for (int i = cin.get(); i != -1; i = cin.get()) |
|
||||
code.push_back((char)i); |
|
||||
else |
|
||||
code = contents(incoming); |
|
||||
bytes data = fromHex(boost::trim_copy(asString(code))); |
|
||||
if (data.empty()) |
|
||||
data = code; |
|
||||
|
|
||||
state.addBalance(sender, value); |
|
||||
Executive executive(state, envInfo); |
|
||||
ExecutionResult res; |
|
||||
executive.setResultRecipient(res); |
|
||||
Transaction t = eth::Transaction(value, gasPrice, gas, data, 0); |
|
||||
t.forceSender(sender); |
|
||||
|
|
||||
unordered_map<byte, pair<unsigned, bigint>> counts; |
|
||||
unsigned total = 0; |
|
||||
bigint memTotal; |
|
||||
auto onOp = [&](uint64_t step, Instruction inst, bigint m, bigint gasCost, bigint gas, VM* vm, ExtVMFace const* extVM) { |
|
||||
if (mode == Mode::Statistics) |
|
||||
{ |
|
||||
counts[(byte)inst].first++; |
|
||||
counts[(byte)inst].second += gasCost; |
|
||||
total++; |
|
||||
if (m > 0) |
|
||||
memTotal = m; |
|
||||
} |
|
||||
else if (mode == Mode::Trace) |
|
||||
st(step, inst, m, gasCost, gas, vm, extVM); |
|
||||
}; |
|
||||
|
|
||||
executive.initialize(t); |
|
||||
executive.create(sender, value, gasPrice, gas, &data, origin); |
|
||||
Timer timer; |
|
||||
executive.go(onOp); |
|
||||
double execTime = timer.elapsed(); |
|
||||
executive.finalize(); |
|
||||
bytes output = std::move(res.output); |
|
||||
|
|
||||
if (mode == Mode::Statistics) |
|
||||
{ |
|
||||
cout << "Gas used: " << res.gasUsed << " (+" << t.gasRequired() << " for transaction, -" << res.gasRefunded << " refunded)" << endl; |
|
||||
cout << "Output: " << toHex(output) << endl; |
|
||||
LogEntries logs = executive.logs(); |
|
||||
cout << logs.size() << " logs" << (logs.empty() ? "." : ":") << endl; |
|
||||
for (LogEntry const& l: logs) |
|
||||
{ |
|
||||
cout << " " << l.address.hex() << ": " << toHex(t.data()) << endl; |
|
||||
for (h256 const& t: l.topics) |
|
||||
cout << " " << t.hex() << endl; |
|
||||
} |
|
||||
|
|
||||
cout << total << " operations in " << execTime << " seconds." << endl; |
|
||||
cout << "Maximum memory usage: " << memTotal * 32 << " bytes" << endl; |
|
||||
cout << "Expensive operations:" << endl; |
|
||||
for (auto const& c: {Instruction::SSTORE, Instruction::SLOAD, Instruction::CALL, Instruction::CREATE, Instruction::CALLCODE, Instruction::MSTORE8, Instruction::MSTORE, Instruction::MLOAD, Instruction::SHA3}) |
|
||||
if (!!counts[(byte)c].first) |
|
||||
cout << " " << instructionInfo(c).name << " x " << counts[(byte)c].first << " (" << counts[(byte)c].second << " gas)" << endl; |
|
||||
} |
|
||||
else if (mode == Mode::Trace) |
|
||||
cout << st.json(styledJson); |
|
||||
else if (mode == Mode::OutputOnly) |
|
||||
cout << toHex(output); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
@ -1 +0,0 @@ |
|||||
/build/ |
|
||||
@ -1,65 +0,0 @@ |
|||||
cmake_minimum_required(VERSION 2.8.12) |
|
||||
|
|
||||
if (${CMAKE_VERSION} VERSION_GREATER 3.0) |
|
||||
cmake_policy(SET CMP0042 OLD) # fix MACOSX_RPATH |
|
||||
cmake_policy(SET CMP0048 NEW) # allow VERSION argument in project() |
|
||||
project(EVMJIT VERSION 0.9.0.1 LANGUAGES CXX) |
|
||||
else() |
|
||||
project(EVMJIT) |
|
||||
set(EVMJIT_VERSION "0.9.0.1") |
|
||||
set(EVMJIT_VERSION_MAJOR 0) |
|
||||
set(EVMJIT_VERSION_MINOR 9) |
|
||||
set(EVMJIT_VERSION_PATCH 0) |
|
||||
set(EVMJIT_VERSION_TWEAK 1) |
|
||||
endif() |
|
||||
|
|
||||
set_property(GLOBAL PROPERTY USE_FOLDERS ON) |
|
||||
set(CMAKE_AUTOMOC OFF) |
|
||||
|
|
||||
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC") |
|
||||
else() |
|
||||
set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wextra -Wconversion -Wno-sign-conversion -Wno-unknown-pragmas ${CMAKE_CXX_FLAGS}") |
|
||||
endif() |
|
||||
|
|
||||
if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND NOT ${CMAKE_BUILD_TYPE} STREQUAL "DebugSan") |
|
||||
# Do not allow unresovled symbols in shared library (default on linux) |
|
||||
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined") |
|
||||
endif() |
|
||||
|
|
||||
# LLVM |
|
||||
if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND NOT LLVM_DIR) |
|
||||
# Workaround for Ubuntu broken LLVM package |
|
||||
find_program(LLVM3_7_CONFIG llvm-config-3.7) |
|
||||
find_program(LLVM3_8_CONFIG llvm-config-3.8) |
|
||||
if (LLVM3_7_CONFIG) |
|
||||
message(STATUS "Using llvm-3.7-dev package from Ubuntu. If does not work, build LLVM and set -DLLVM_DIR=llvm-build/share/llvm/cmake") |
|
||||
set(LLVM_CONFIG_EXEC llvm-config-3.7) |
|
||||
set(LLVM_LIB_DIR /usr/lib/llvm-3.7/lib) |
|
||||
elseif(LLVM3_8_CONFIG) |
|
||||
message(STATUS "Using llvm-3.8-dev package from Ubuntu. If does not work, build LLVM and set -DLLVM_DIR=llvm-build/share/llvm/cmake") |
|
||||
set(LLVM_CONFIG_EXEC llvm-config-3.8) |
|
||||
set(LLVM_LIB_DIR /usr/lib/llvm-3.8/lib) |
|
||||
else() |
|
||||
message(FATAL_ERROR "No LLVM package found!") |
|
||||
endif() |
|
||||
|
|
||||
execute_process(COMMAND ${LLVM_CONFIG_EXEC} --includedir OUTPUT_VARIABLE LLVM_INCLUDE_DIRS OUTPUT_STRIP_TRAILING_WHITESPACE) |
|
||||
message(STATUS "LLVM include dirs: ${LLVM_INCLUDE_DIRS}") |
|
||||
set(LLVM_LIBS "-lLLVMipo -lLLVMVectorize -lLLVMX86AsmParser -lLLVMX86CodeGen -lLLVMX86Desc -lLLVMX86Info -lLLVMMCDisassembler -lLLVMX86AsmPrinter -lLLVMX86Utils -lLLVMSelectionDAG -lLLVMAsmPrinter -lLLVMCodeGen -lLLVMScalarOpts -lLLVMProfileData -lLLVMInstCombine -lLLVMInstrumentation -lLLVMTransformUtils -lLLVMipa -lLLVMMCJIT -lLLVMExecutionEngine -lLLVMTarget -lLLVMAnalysis -lLLVMRuntimeDyld -lLLVMObject -lLLVMMCParser -lLLVMBitReader -lLLVMMC -lLLVMCore -lLLVMSupport -lz -lpthread -lffi -ltinfo -ldl -lm") |
|
||||
set(LLVM_DEFINITIONS "-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS") |
|
||||
link_directories(${LLVM_LIB_DIR}) |
|
||||
else() |
|
||||
find_package(LLVM REQUIRED CONFIG) |
|
||||
if (${LLVM_VERSION} VERSION_LESS 3.7) |
|
||||
message(FATAL_ERROR "Incompatible LLVM version ${LLVM_VERSION}") |
|
||||
endif() |
|
||||
message(STATUS "Found LLVM ${LLVM_VERSION}") |
|
||||
message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}") |
|
||||
llvm_map_components_to_libnames(LLVM_LIBS core support mcjit x86asmparser x86codegen ipo) |
|
||||
endif() |
|
||||
|
|
||||
add_subdirectory(libevmjit) |
|
||||
|
|
||||
if(EVMJIT_CPP) |
|
||||
add_subdirectory(libevmjit-cpp) |
|
||||
endif() |
|
||||
@ -1,21 +0,0 @@ |
|||||
The MIT License (MIT) |
|
||||
|
|
||||
Copyright (c) 2015 Paweł Bylica <chfast@gmail.com> |
|
||||
|
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|
||||
of this software and associated documentation files (the "Software"), to deal |
|
||||
in the Software without restriction, including without limitation the rights |
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
||||
copies of the Software, and to permit persons to whom the Software is |
|
||||
furnished to do so, subject to the following conditions: |
|
||||
|
|
||||
The above copyright notice and this permission notice shall be included in all |
|
||||
copies or substantial portions of the Software. |
|
||||
|
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
||||
SOFTWARE. |
|
||||
@ -1,36 +0,0 @@ |
|||||
# The Ethereum EVM JIT |
|
||||
|
|
||||
EVM JIT is a library for just-in-time compilation of Ethereum EVM code. |
|
||||
It can be used to substitute classic interpreter-like EVM Virtual Machine in Ethereum client. |
|
||||
|
|
||||
## Build |
|
||||
|
|
||||
### Linux / Ubuntu |
|
||||
|
|
||||
1. Install llvm-3.5-dev package |
|
||||
1. For Ubuntu 14.04 using LLVM deb packages source: http://llvm.org/apt |
|
||||
2. For Ubuntu 14.10 using Ubuntu packages |
|
||||
2. Build library with cmake |
|
||||
1. `mkdir build && cd $_` |
|
||||
2. `cmake .. && make` |
|
||||
3. Install library |
|
||||
1. `sudo make install` |
|
||||
2. `sudo ldconfig` |
|
||||
|
|
||||
### OSX |
|
||||
|
|
||||
1. Install llvm35 |
|
||||
1. `brew install llvm35 --disable-shared --HEAD` |
|
||||
2. Build library with cmake |
|
||||
1. `mkdir build && cd $_` |
|
||||
2. `cmake -DLLVM_DIR=/usr/local/lib/llvm-3.5/share/llvm/cmake .. && make` |
|
||||
3. Install library |
|
||||
1. `make install` (with admin rights?) |
|
||||
|
|
||||
### Windows |
|
||||
|
|
||||
Ask me. |
|
||||
|
|
||||
## Options |
|
||||
|
|
||||
Options to evmjit library can be passed by environmental variable, e.g. `EVMJIT="-help" testeth --jit`. |
|
||||
@ -1,70 +0,0 @@ |
|||||
|
|
||||
#include "stdint.h" |
|
||||
|
|
||||
#ifdef _MSC_VER |
|
||||
#define EXPORT __declspec(dllexport) |
|
||||
#define _ALLOW_KEYWORD_MACROS |
|
||||
#define noexcept throw() |
|
||||
#else |
|
||||
#define EXPORT |
|
||||
#endif |
|
||||
|
|
||||
#ifdef __cplusplus |
|
||||
extern "C" { |
|
||||
#endif |
|
||||
|
|
||||
typedef struct evmjit_i256 |
|
||||
{ |
|
||||
uint64_t words[4]; |
|
||||
} evmjit_i256; |
|
||||
|
|
||||
typedef struct evmjit_runtime_data |
|
||||
{ |
|
||||
int64_t gas; |
|
||||
int64_t gasPrice; |
|
||||
char const* callData; |
|
||||
uint64_t callDataSize; |
|
||||
evmjit_i256 address; |
|
||||
evmjit_i256 caller; |
|
||||
evmjit_i256 origin; |
|
||||
evmjit_i256 callValue; |
|
||||
evmjit_i256 coinBase; |
|
||||
evmjit_i256 difficulty; |
|
||||
evmjit_i256 gasLimit; |
|
||||
uint64_t number; |
|
||||
int64_t timestamp; |
|
||||
char const* code; |
|
||||
uint64_t codeSize; |
|
||||
evmjit_i256 codeHash; |
|
||||
} evmjit_runtime_data; |
|
||||
|
|
||||
typedef enum evmjit_return_code |
|
||||
{ |
|
||||
// Success codes
|
|
||||
Stop = 0, |
|
||||
Return = 1, |
|
||||
Suicide = 2, |
|
||||
|
|
||||
// Standard error codes
|
|
||||
OutOfGas = -1, |
|
||||
|
|
||||
// Internal error codes
|
|
||||
LLVMError = -101, |
|
||||
UnexpectedException = -111 |
|
||||
} evmjit_return_code; |
|
||||
|
|
||||
typedef struct evmjit_context evmjit_context; |
|
||||
|
|
||||
EXPORT evmjit_context* evmjit_create(evmjit_runtime_data* _data, void* _env); |
|
||||
|
|
||||
EXPORT evmjit_return_code evmjit_exec(evmjit_context* _context); |
|
||||
|
|
||||
EXPORT void evmjit_destroy(evmjit_context* _context); |
|
||||
|
|
||||
|
|
||||
inline char const* evmjit_get_output(evmjit_runtime_data* _data) { return _data->callData; } |
|
||||
inline uint64_t evmjit_get_output_size(evmjit_runtime_data* _data) { return _data->callDataSize; } |
|
||||
|
|
||||
#ifdef __cplusplus |
|
||||
} |
|
||||
#endif |
|
||||
@ -1,172 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <cstdint> |
|
||||
#include <cstring> |
|
||||
#include <functional> |
|
||||
|
|
||||
#ifdef _MSC_VER |
|
||||
#define EXPORT __declspec(dllexport) |
|
||||
#define _ALLOW_KEYWORD_MACROS |
|
||||
#define noexcept throw() |
|
||||
#else |
|
||||
#define EXPORT |
|
||||
#endif |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
using byte = uint8_t; |
|
||||
using bytes_ref = std::tuple<byte const*, size_t>; |
|
||||
|
|
||||
/// Representation of 256-bit hash value
|
|
||||
struct h256 |
|
||||
{ |
|
||||
uint64_t words[4]; |
|
||||
}; |
|
||||
|
|
||||
inline bool operator==(h256 const& _h1, h256 const& _h2) |
|
||||
{ |
|
||||
return _h1.words[0] == _h2.words[0] && |
|
||||
_h1.words[1] == _h2.words[1] && |
|
||||
_h1.words[2] == _h2.words[2] && |
|
||||
_h1.words[3] == _h2.words[3]; |
|
||||
} |
|
||||
|
|
||||
/// Representation of 256-bit value binary compatible with LLVM i256
|
|
||||
struct i256 |
|
||||
{ |
|
||||
uint64_t words[4]; |
|
||||
|
|
||||
i256() = default; |
|
||||
i256(h256 const& _h) { std::memcpy(this, &_h, sizeof(*this)); } |
|
||||
}; |
|
||||
|
|
||||
// TODO: Merge with ExecutionContext
|
|
||||
struct RuntimeData |
|
||||
{ |
|
||||
enum Index |
|
||||
{ |
|
||||
Gas, |
|
||||
GasPrice, |
|
||||
CallData, |
|
||||
CallDataSize, |
|
||||
Address, |
|
||||
Caller, |
|
||||
Origin, |
|
||||
CallValue, |
|
||||
CoinBase, |
|
||||
Difficulty, |
|
||||
GasLimit, |
|
||||
Number, |
|
||||
Timestamp, |
|
||||
Code, |
|
||||
CodeSize, |
|
||||
|
|
||||
SuicideDestAddress = Address, ///< Suicide balance destination address
|
|
||||
ReturnData = CallData, ///< Return data pointer (set only in case of RETURN)
|
|
||||
ReturnDataSize = CallDataSize, ///< Return data size (set only in case of RETURN)
|
|
||||
}; |
|
||||
|
|
||||
static size_t const numElements = CodeSize + 1; |
|
||||
|
|
||||
int64_t gas = 0; |
|
||||
int64_t gasPrice = 0; |
|
||||
byte const* callData = nullptr; |
|
||||
uint64_t callDataSize = 0; |
|
||||
i256 address; |
|
||||
i256 caller; |
|
||||
i256 origin; |
|
||||
i256 callValue; |
|
||||
i256 coinBase; |
|
||||
i256 difficulty; |
|
||||
i256 gasLimit; |
|
||||
uint64_t number = 0; |
|
||||
int64_t timestamp = 0; |
|
||||
byte const* code = nullptr; |
|
||||
uint64_t codeSize = 0; |
|
||||
h256 codeHash; |
|
||||
}; |
|
||||
|
|
||||
/// VM Environment (ExtVM) opaque type
|
|
||||
struct Env; |
|
||||
|
|
||||
enum class ReturnCode |
|
||||
{ |
|
||||
// Success codes
|
|
||||
Stop = 0, |
|
||||
Return = 1, |
|
||||
Suicide = 2, |
|
||||
|
|
||||
// Standard error codes
|
|
||||
OutOfGas = -1, |
|
||||
|
|
||||
// Internal error codes
|
|
||||
LLVMError = -101, |
|
||||
|
|
||||
UnexpectedException = -111, |
|
||||
|
|
||||
LinkerWorkaround = -299, |
|
||||
}; |
|
||||
|
|
||||
class ExecutionContext |
|
||||
{ |
|
||||
public: |
|
||||
ExecutionContext() = default; |
|
||||
ExecutionContext(RuntimeData& _data, Env* _env) { init(_data, _env); } |
|
||||
ExecutionContext(ExecutionContext const&) = delete; |
|
||||
ExecutionContext& operator=(ExecutionContext const&) = delete; |
|
||||
EXPORT ~ExecutionContext() noexcept; |
|
||||
|
|
||||
void init(RuntimeData& _data, Env* _env) { m_data = &_data; m_env = _env; } |
|
||||
|
|
||||
byte const* code() const { return m_data->code; } |
|
||||
uint64_t codeSize() const { return m_data->codeSize; } |
|
||||
h256 const& codeHash() const { return m_data->codeHash; } |
|
||||
|
|
||||
bytes_ref getReturnData() const; |
|
||||
|
|
||||
protected: |
|
||||
RuntimeData* m_data = nullptr; ///< Pointer to data. Expected by compiled contract.
|
|
||||
Env* m_env = nullptr; ///< Pointer to environment proxy. Expected by compiled contract.
|
|
||||
byte* m_memData = nullptr; |
|
||||
uint64_t m_memSize = 0; |
|
||||
uint64_t m_memCap = 0; |
|
||||
|
|
||||
public: |
|
||||
/// Reference to returned data (RETURN opcode used)
|
|
||||
bytes_ref returnData; |
|
||||
}; |
|
||||
|
|
||||
class JIT |
|
||||
{ |
|
||||
public: |
|
||||
|
|
||||
/// Ask JIT if the EVM code is ready for execution.
|
|
||||
/// Returns `true` if the EVM code has been compiled and loaded into memory.
|
|
||||
/// In this case the code can be executed without overhead.
|
|
||||
/// \param _codeHash The Keccak hash of the EVM code.
|
|
||||
EXPORT static bool isCodeReady(h256 const& _codeHash); |
|
||||
|
|
||||
/// Compile the given EVM code to machine code and make available for execution.
|
|
||||
EXPORT static void compile(byte const* _code, uint64_t _codeSize, h256 const& _codeHash); |
|
||||
|
|
||||
EXPORT static ReturnCode exec(ExecutionContext& _context); |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
namespace std |
|
||||
{ |
|
||||
template<> struct hash<dev::evmjit::h256> |
|
||||
{ |
|
||||
size_t operator()(dev::evmjit::h256 const& _h) const |
|
||||
{ |
|
||||
/// This implementation expects the argument to be a full 256-bit Keccak hash.
|
|
||||
/// It does nothing more than returning a slice of the input hash.
|
|
||||
return static_cast<size_t>(_h.words[0]); |
|
||||
}; |
|
||||
}; |
|
||||
} |
|
||||
@ -1,24 +0,0 @@ |
|||||
set(TARGET_NAME evmjit-cpp) |
|
||||
|
|
||||
# Boost |
|
||||
find_package(Boost REQUIRED) |
|
||||
|
|
||||
set(SOURCES |
|
||||
Env.cpp |
|
||||
JitVM.cpp JitVM.h |
|
||||
Utils.h |
|
||||
) |
|
||||
source_group("" FILES ${SOURCES}) |
|
||||
|
|
||||
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC") |
|
||||
else() |
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") # add PIC for archive |
|
||||
endif() |
|
||||
|
|
||||
add_library(${TARGET_NAME} STATIC ${SOURCES}) |
|
||||
set_property(TARGET ${TARGET_NAME} PROPERTY FOLDER "libs") |
|
||||
|
|
||||
include_directories(../..) |
|
||||
include_directories(${Boost_INCLUDE_DIRS}) |
|
||||
|
|
||||
target_link_libraries(${TARGET_NAME} evmjit) |
|
||||
@ -1,135 +0,0 @@ |
|||||
|
|
||||
#pragma GCC diagnostic ignored "-Wconversion" |
|
||||
#include <libdevcore/SHA3.h> |
|
||||
#include <libevmcore/Params.h> |
|
||||
#include <libevm/ExtVMFace.h> |
|
||||
|
|
||||
#include "Utils.h" |
|
||||
|
|
||||
extern "C" |
|
||||
{ |
|
||||
#ifdef _MSC_VER |
|
||||
#define EXPORT __declspec(dllexport) |
|
||||
#else |
|
||||
#define EXPORT |
|
||||
#endif |
|
||||
|
|
||||
using namespace dev; |
|
||||
using namespace dev::eth; |
|
||||
using evmjit::i256; |
|
||||
|
|
||||
EXPORT void env_sload(ExtVMFace* _env, i256* _index, i256* o_value) |
|
||||
{ |
|
||||
auto index = jit2eth(*_index); |
|
||||
auto value = _env->store(index); // Interface uses native endianness
|
|
||||
*o_value = eth2jit(value); |
|
||||
} |
|
||||
|
|
||||
EXPORT void env_sstore(ExtVMFace* _env, i256* _index, i256* _value) |
|
||||
{ |
|
||||
auto index = jit2eth(*_index); |
|
||||
auto value = jit2eth(*_value); |
|
||||
|
|
||||
if (value == 0 && _env->store(index) != 0) // If delete
|
|
||||
_env->sub.refunds += c_sstoreRefundGas; // Increase refund counter
|
|
||||
|
|
||||
_env->setStore(index, value); // Interface uses native endianness
|
|
||||
} |
|
||||
|
|
||||
EXPORT void env_balance(ExtVMFace* _env, h256* _address, i256* o_value) |
|
||||
{ |
|
||||
auto u = _env->balance(right160(*_address)); |
|
||||
*o_value = eth2jit(u); |
|
||||
} |
|
||||
|
|
||||
EXPORT void env_blockhash(ExtVMFace* _env, i256* _number, h256* o_hash) |
|
||||
{ |
|
||||
*o_hash = _env->blockHash(jit2eth(*_number)); |
|
||||
} |
|
||||
|
|
||||
EXPORT void env_create(ExtVMFace* _env, int64_t* io_gas, i256* _endowment, byte* _initBeg, uint64_t _initSize, h256* o_address) |
|
||||
{ |
|
||||
auto endowment = jit2eth(*_endowment); |
|
||||
if (_env->balance(_env->myAddress) >= endowment && _env->depth < 1024) |
|
||||
{ |
|
||||
u256 gas = *io_gas; |
|
||||
h256 address(_env->create(endowment, gas, {_initBeg, (size_t)_initSize}, {}), h256::AlignRight); |
|
||||
*io_gas = static_cast<int64_t>(gas); |
|
||||
*o_address = address; |
|
||||
} |
|
||||
else |
|
||||
*o_address = {}; |
|
||||
} |
|
||||
|
|
||||
EXPORT bool env_call(ExtVMFace* _env, int64_t* io_gas, int64_t _callGas, h256* _receiveAddress, i256* _value, byte* _inBeg, uint64_t _inSize, byte* _outBeg, uint64_t _outSize, h256* _codeAddress) |
|
||||
{ |
|
||||
CallParameters params; |
|
||||
params.value = jit2eth(*_value); |
|
||||
params.senderAddress = _env->myAddress; |
|
||||
params.receiveAddress = right160(*_receiveAddress); |
|
||||
params.codeAddress = right160(*_codeAddress); |
|
||||
params.data = {_inBeg, (size_t)_inSize}; |
|
||||
params.out = {_outBeg, (size_t)_outSize}; |
|
||||
params.onOp = {}; |
|
||||
const auto isCall = params.receiveAddress == params.codeAddress; // OPT: The same address pointer can be used if not CODECALL
|
|
||||
|
|
||||
*io_gas -= _callGas; |
|
||||
if (*io_gas < 0) |
|
||||
return false; |
|
||||
|
|
||||
if (isCall && !_env->exists(params.receiveAddress)) |
|
||||
*io_gas -= static_cast<int64_t>(c_callNewAccountGas); // no underflow, *io_gas non-negative before
|
|
||||
|
|
||||
if (params.value > 0) // value transfer
|
|
||||
{ |
|
||||
/*static*/ assert(c_callValueTransferGas > c_callStipend && "Overflow possible"); |
|
||||
*io_gas -= static_cast<int64_t>(c_callValueTransferGas); // no underflow
|
|
||||
_callGas += static_cast<int64_t>(c_callStipend); // overflow possibility, but in the same time *io_gas < 0
|
|
||||
} |
|
||||
|
|
||||
if (*io_gas < 0) |
|
||||
return false; |
|
||||
|
|
||||
auto ret = false; |
|
||||
params.gas = u256{_callGas}; |
|
||||
if (_env->balance(_env->myAddress) >= params.value && _env->depth < 1024) |
|
||||
ret = _env->call(params); |
|
||||
|
|
||||
*io_gas += static_cast<int64_t>(params.gas); // it is never more than initial _callGas
|
|
||||
return ret; |
|
||||
} |
|
||||
|
|
||||
EXPORT void env_sha3(byte* _begin, uint64_t _size, h256* o_hash) |
|
||||
{ |
|
||||
auto hash = sha3({_begin, (size_t)_size}); |
|
||||
*o_hash = hash; |
|
||||
} |
|
||||
|
|
||||
EXPORT byte const* env_extcode(ExtVMFace* _env, h256* _addr256, uint64_t* o_size) |
|
||||
{ |
|
||||
auto addr = right160(*_addr256); |
|
||||
auto& code = _env->codeAt(addr); |
|
||||
*o_size = code.size(); |
|
||||
return code.data(); |
|
||||
} |
|
||||
|
|
||||
EXPORT void env_log(ExtVMFace* _env, byte* _beg, uint64_t _size, h256* _topic1, h256* _topic2, h256* _topic3, h256* _topic4) |
|
||||
{ |
|
||||
dev::h256s topics; |
|
||||
|
|
||||
if (_topic1) |
|
||||
topics.push_back(*_topic1); |
|
||||
|
|
||||
if (_topic2) |
|
||||
topics.push_back(*_topic2); |
|
||||
|
|
||||
if (_topic3) |
|
||||
topics.push_back(*_topic3); |
|
||||
|
|
||||
if (_topic4) |
|
||||
topics.push_back(*_topic4); |
|
||||
|
|
||||
_env->log(std::move(topics), {_beg, (size_t)_size}); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,77 +0,0 @@ |
|||||
|
|
||||
#pragma GCC diagnostic ignored "-Wconversion" |
|
||||
|
|
||||
#include "JitVM.h" |
|
||||
|
|
||||
#include <libdevcore/Log.h> |
|
||||
#include <libdevcore/SHA3.h> |
|
||||
#include <libevm/VM.h> |
|
||||
#include <libevm/VMFactory.h> |
|
||||
|
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
|
|
||||
extern "C" void env_sload(); // fake declaration for linker symbol stripping workaround, see a call below
|
|
||||
|
|
||||
bytesConstRef JitVM::execImpl(u256& io_gas, ExtVMFace& _ext, OnOpFunc const& _onOp) |
|
||||
{ |
|
||||
auto rejected = false; |
|
||||
// TODO: Rejecting transactions with gas limit > 2^63 can be used by attacker to take JIT out of scope
|
|
||||
rejected |= io_gas > std::numeric_limits<decltype(m_data.gas)>::max(); // Do not accept requests with gas > 2^63 (int64 max)
|
|
||||
rejected |= _ext.gasPrice > std::numeric_limits<decltype(m_data.gasPrice)>::max(); |
|
||||
rejected |= _ext.envInfo().number() > std::numeric_limits<decltype(m_data.number)>::max(); |
|
||||
rejected |= _ext.envInfo().timestamp() > std::numeric_limits<decltype(m_data.timestamp)>::max(); |
|
||||
|
|
||||
if (rejected) |
|
||||
{ |
|
||||
cwarn << "Execution rejected by EVM JIT (gas limit: " << io_gas << "), executing with interpreter"; |
|
||||
m_fallbackVM = VMFactory::create(VMKind::Interpreter); |
|
||||
return m_fallbackVM->execImpl(io_gas, _ext, _onOp); |
|
||||
} |
|
||||
|
|
||||
m_data.gas = static_cast<decltype(m_data.gas)>(io_gas); |
|
||||
m_data.gasPrice = static_cast<decltype(m_data.gasPrice)>(_ext.gasPrice); |
|
||||
m_data.callData = _ext.data.data(); |
|
||||
m_data.callDataSize = _ext.data.size(); |
|
||||
m_data.address = eth2jit(fromAddress(_ext.myAddress)); |
|
||||
m_data.caller = eth2jit(fromAddress(_ext.caller)); |
|
||||
m_data.origin = eth2jit(fromAddress(_ext.origin)); |
|
||||
m_data.callValue = eth2jit(_ext.value); |
|
||||
m_data.coinBase = eth2jit(fromAddress(_ext.envInfo().beneficiary())); |
|
||||
m_data.difficulty = eth2jit(_ext.envInfo().difficulty()); |
|
||||
m_data.gasLimit = eth2jit(_ext.envInfo().gasLimit()); |
|
||||
m_data.number = static_cast<decltype(m_data.number)>(_ext.envInfo().number()); |
|
||||
m_data.timestamp = static_cast<decltype(m_data.timestamp)>(_ext.envInfo().timestamp()); |
|
||||
m_data.code = _ext.code.data(); |
|
||||
m_data.codeSize = _ext.code.size(); |
|
||||
m_data.codeHash = eth2jit(_ext.codeHash); |
|
||||
|
|
||||
// Pass pointer to ExtVMFace casted to evmjit::Env* opaque type.
|
|
||||
// JIT will do nothing with the pointer, just pass it to Env callback functions implemented in Env.cpp.
|
|
||||
m_context.init(m_data, reinterpret_cast<evmjit::Env*>(&_ext)); |
|
||||
auto exitCode = evmjit::JIT::exec(m_context); |
|
||||
switch (exitCode) |
|
||||
{ |
|
||||
case evmjit::ReturnCode::Suicide: |
|
||||
_ext.suicide(right160(jit2eth(m_data.address))); |
|
||||
break; |
|
||||
|
|
||||
case evmjit::ReturnCode::OutOfGas: |
|
||||
BOOST_THROW_EXCEPTION(OutOfGas()); |
|
||||
case evmjit::ReturnCode::LinkerWorkaround: // never happens
|
|
||||
env_sload(); // but forces linker to include env_* JIT callback functions
|
|
||||
break; |
|
||||
default: |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
io_gas = m_data.gas; |
|
||||
return {std::get<0>(m_context.returnData), std::get<1>(m_context.returnData)}; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,24 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <libevm/VMFace.h> |
|
||||
#include <evmjit/JIT.h> |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
|
|
||||
class JitVM: public VMFace |
|
||||
{ |
|
||||
public: |
|
||||
virtual bytesConstRef execImpl(u256& io_gas, ExtVMFace& _ext, OnOpFunc const& _onOp) override final; |
|
||||
|
|
||||
private: |
|
||||
evmjit::RuntimeData m_data; |
|
||||
evmjit::ExecutionContext m_context; |
|
||||
std::unique_ptr<VMFace> m_fallbackVM; ///< VM used in case of input data rejected by JIT
|
|
||||
}; |
|
||||
|
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,45 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <evmjit/JIT.h> |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
|
|
||||
/// Converts EVM JIT representation of 256-bit integer to eth type dev::u256.
|
|
||||
inline u256 jit2eth(evmjit::i256 _i) |
|
||||
{ |
|
||||
u256 u = _i.words[3]; |
|
||||
u <<= 64; |
|
||||
u |= _i.words[2]; |
|
||||
u <<= 64; |
|
||||
u |= _i.words[1]; |
|
||||
u <<= 64; |
|
||||
u |= _i.words[0]; |
|
||||
return u; |
|
||||
} |
|
||||
|
|
||||
/// Converts eth type dev::u256 to EVM JIT representation of 256-bit integer.
|
|
||||
inline evmjit::i256 eth2jit(u256 _u) |
|
||||
{ |
|
||||
evmjit::i256 i; |
|
||||
i.words[0] = static_cast<uint64_t>(_u); |
|
||||
_u >>= 64; |
|
||||
i.words[1] = static_cast<uint64_t>(_u); |
|
||||
_u >>= 64; |
|
||||
i.words[2] = static_cast<uint64_t>(_u); |
|
||||
_u >>= 64; |
|
||||
i.words[3] = static_cast<uint64_t>(_u); |
|
||||
return i; |
|
||||
} |
|
||||
|
|
||||
/// Converts eth type dev::h256 to EVM JIT representation of 256-bit hash value.
|
|
||||
inline evmjit::h256 eth2jit(h256 _u) |
|
||||
{ |
|
||||
/// Just directly copies memory
|
|
||||
return *(evmjit::h256*)&_u; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,508 +0,0 @@ |
|||||
#include "Arith256.h" |
|
||||
|
|
||||
#include <iostream> |
|
||||
#include <iomanip> |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Module.h> |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Type.h" |
|
||||
#include "Endianness.h" |
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
Arith256::Arith256(llvm::IRBuilder<>& _builder) : |
|
||||
CompilerHelper(_builder) |
|
||||
{} |
|
||||
|
|
||||
void Arith256::debug(llvm::Value* _value, char _c) |
|
||||
{ |
|
||||
if (!m_debug) |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {Type::Word, m_builder.getInt8Ty()}; |
|
||||
m_debug = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::ExternalLinkage, "debug", getModule()); |
|
||||
} |
|
||||
createCall(m_debug, {m_builder.CreateZExtOrTrunc(_value, Type::Word), m_builder.getInt8(_c)}); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getMulFunc(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.mul.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
llvm::Type* argTypes[] = {Type::Word, Type::Word}; |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Word, argTypes, false), llvm::Function::PrivateLinkage, funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), {}, func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
auto i64 = Type::Size; |
|
||||
auto i128 = builder.getIntNTy(128); |
|
||||
auto i256 = Type::Word; |
|
||||
auto c64 = Constant::get(64); |
|
||||
auto c128 = Constant::get(128); |
|
||||
auto c192 = Constant::get(192); |
|
||||
|
|
||||
auto x_lo = builder.CreateTrunc(x, i64, "x.lo"); |
|
||||
auto y_lo = builder.CreateTrunc(y, i64, "y.lo"); |
|
||||
auto x_mi = builder.CreateTrunc(builder.CreateLShr(x, c64), i64); |
|
||||
auto y_mi = builder.CreateTrunc(builder.CreateLShr(y, c64), i64); |
|
||||
auto x_hi = builder.CreateTrunc(builder.CreateLShr(x, c128), i128); |
|
||||
auto y_hi = builder.CreateTrunc(builder.CreateLShr(y, c128), i128); |
|
||||
|
|
||||
auto t1 = builder.CreateMul(builder.CreateZExt(x_lo, i128), builder.CreateZExt(y_lo, i128)); |
|
||||
auto t2 = builder.CreateMul(builder.CreateZExt(x_lo, i128), builder.CreateZExt(y_mi, i128)); |
|
||||
auto t3 = builder.CreateMul(builder.CreateZExt(x_lo, i128), y_hi); |
|
||||
auto t4 = builder.CreateMul(builder.CreateZExt(x_mi, i128), builder.CreateZExt(y_lo, i128)); |
|
||||
auto t5 = builder.CreateMul(builder.CreateZExt(x_mi, i128), builder.CreateZExt(y_mi, i128)); |
|
||||
auto t6 = builder.CreateMul(builder.CreateZExt(x_mi, i128), y_hi); |
|
||||
auto t7 = builder.CreateMul(x_hi, builder.CreateZExt(y_lo, i128)); |
|
||||
auto t8 = builder.CreateMul(x_hi, builder.CreateZExt(y_mi, i128)); |
|
||||
|
|
||||
auto p = builder.CreateZExt(t1, i256); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t2, i256), c64)); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t3, i256), c128)); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t4, i256), c64)); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t5, i256), c128)); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t6, i256), c192)); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t7, i256), c128)); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t8, i256), c192)); |
|
||||
builder.CreateRet(p); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getMul512Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.mul.i512"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
auto i512Ty = llvm::IntegerType::get(_module.getContext(), 512); |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(i512Ty, {Type::Word, Type::Word}, false), llvm::Function::PrivateLinkage, funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), {}, func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
|
|
||||
auto i128 = builder.getIntNTy(128); |
|
||||
auto i256 = Type::Word; |
|
||||
auto x_lo = builder.CreateZExt(builder.CreateTrunc(x, i128, "x.lo"), i256); |
|
||||
auto y_lo = builder.CreateZExt(builder.CreateTrunc(y, i128, "y.lo"), i256); |
|
||||
auto x_hi = builder.CreateZExt(builder.CreateTrunc(builder.CreateLShr(x, Constant::get(128)), i128, "x.hi"), i256); |
|
||||
auto y_hi = builder.CreateZExt(builder.CreateTrunc(builder.CreateLShr(y, Constant::get(128)), i128, "y.hi"), i256); |
|
||||
|
|
||||
auto mul256Func = getMulFunc(_module); |
|
||||
auto t1 = builder.CreateCall(mul256Func, {x_lo, y_lo}); |
|
||||
auto t2 = builder.CreateCall(mul256Func, {x_lo, y_hi}); |
|
||||
auto t3 = builder.CreateCall(mul256Func, {x_hi, y_lo}); |
|
||||
auto t4 = builder.CreateCall(mul256Func, {x_hi, y_hi}); |
|
||||
|
|
||||
auto p = builder.CreateZExt(t1, i512Ty); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t2, i512Ty), builder.getIntN(512, 128))); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t3, i512Ty), builder.getIntN(512, 128))); |
|
||||
p = builder.CreateAdd(p, builder.CreateShl(builder.CreateZExt(t4, i512Ty), builder.getIntN(512, 256))); |
|
||||
builder.CreateRet(p); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
llvm::Function* createUDivRemFunc(llvm::Type* _type, llvm::Module& _module, char const* _funcName) |
|
||||
{ |
|
||||
// Based of "Improved shift divisor algorithm" from "Software Integer Division" by Microsoft Research
|
|
||||
// The following algorithm also handles divisor of value 0 returning 0 for both quotient and remainder
|
|
||||
|
|
||||
auto retType = llvm::VectorType::get(_type, 2); |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(retType, {_type, _type}, false), llvm::Function::PrivateLinkage, _funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto zero = llvm::ConstantInt::get(_type, 0); |
|
||||
auto one = llvm::ConstantInt::get(_type, 1); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto yArg = x->getNextNode(); |
|
||||
yArg->setName("y"); |
|
||||
|
|
||||
auto entryBB = llvm::BasicBlock::Create(_module.getContext(), "Entry", func); |
|
||||
auto mainBB = llvm::BasicBlock::Create(_module.getContext(), "Main", func); |
|
||||
auto loopBB = llvm::BasicBlock::Create(_module.getContext(), "Loop", func); |
|
||||
auto continueBB = llvm::BasicBlock::Create(_module.getContext(), "Continue", func); |
|
||||
auto returnBB = llvm::BasicBlock::Create(_module.getContext(), "Return", func); |
|
||||
|
|
||||
auto builder = llvm::IRBuilder<>{entryBB}; |
|
||||
auto yLEx = builder.CreateICmpULE(yArg, x); |
|
||||
auto r0 = x; |
|
||||
builder.CreateCondBr(yLEx, mainBB, returnBB); |
|
||||
|
|
||||
builder.SetInsertPoint(mainBB); |
|
||||
auto ctlzIntr = llvm::Intrinsic::getDeclaration(&_module, llvm::Intrinsic::ctlz, _type); |
|
||||
// both y and r are non-zero
|
|
||||
auto yLz = builder.CreateCall(ctlzIntr, {yArg, builder.getInt1(true)}, "y.lz"); |
|
||||
auto rLz = builder.CreateCall(ctlzIntr, {r0, builder.getInt1(true)}, "r.lz"); |
|
||||
auto i0 = builder.CreateNUWSub(yLz, rLz, "i0"); |
|
||||
auto y0 = builder.CreateShl(yArg, i0); |
|
||||
builder.CreateBr(loopBB); |
|
||||
|
|
||||
builder.SetInsertPoint(loopBB); |
|
||||
auto yPhi = builder.CreatePHI(_type, 2, "y.phi"); |
|
||||
auto rPhi = builder.CreatePHI(_type, 2, "r.phi"); |
|
||||
auto iPhi = builder.CreatePHI(_type, 2, "i.phi"); |
|
||||
auto qPhi = builder.CreatePHI(_type, 2, "q.phi"); |
|
||||
auto rUpdate = builder.CreateNUWSub(rPhi, yPhi); |
|
||||
auto qUpdate = builder.CreateOr(qPhi, one); // q += 1, q lowest bit is 0
|
|
||||
auto rGEy = builder.CreateICmpUGE(rPhi, yPhi); |
|
||||
auto r1 = builder.CreateSelect(rGEy, rUpdate, rPhi, "r1"); |
|
||||
auto q1 = builder.CreateSelect(rGEy, qUpdate, qPhi, "q"); |
|
||||
auto iZero = builder.CreateICmpEQ(iPhi, zero); |
|
||||
builder.CreateCondBr(iZero, returnBB, continueBB); |
|
||||
|
|
||||
builder.SetInsertPoint(continueBB); |
|
||||
auto i2 = builder.CreateNUWSub(iPhi, one); |
|
||||
auto q2 = builder.CreateShl(q1, one); |
|
||||
auto y2 = builder.CreateLShr(yPhi, one); |
|
||||
builder.CreateBr(loopBB); |
|
||||
|
|
||||
yPhi->addIncoming(y0, mainBB); |
|
||||
yPhi->addIncoming(y2, continueBB); |
|
||||
rPhi->addIncoming(r0, mainBB); |
|
||||
rPhi->addIncoming(r1, continueBB); |
|
||||
iPhi->addIncoming(i0, mainBB); |
|
||||
iPhi->addIncoming(i2, continueBB); |
|
||||
qPhi->addIncoming(zero, mainBB); |
|
||||
qPhi->addIncoming(q2, continueBB); |
|
||||
|
|
||||
builder.SetInsertPoint(returnBB); |
|
||||
auto qRet = builder.CreatePHI(_type, 2, "q.ret"); |
|
||||
qRet->addIncoming(zero, entryBB); |
|
||||
qRet->addIncoming(q1, loopBB); |
|
||||
auto rRet = builder.CreatePHI(_type, 2, "r.ret"); |
|
||||
rRet->addIncoming(r0, entryBB); |
|
||||
rRet->addIncoming(r1, loopBB); |
|
||||
auto ret = builder.CreateInsertElement(llvm::UndefValue::get(retType), qRet, uint64_t(0), "ret0"); |
|
||||
ret = builder.CreateInsertElement(ret, rRet, 1, "ret"); |
|
||||
builder.CreateRet(ret); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getUDivRem256Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.udivrem.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
return createUDivRemFunc(Type::Word, _module, funcName); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getUDivRem512Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.udivrem.i512"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
return createUDivRemFunc(llvm::IntegerType::get(_module.getContext(), 512), _module, funcName); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getUDiv256Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.udiv.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
auto udivremFunc = getUDivRem256Func(_module); |
|
||||
|
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Word, {Type::Word, Type::Word}, false), llvm::Function::PrivateLinkage, funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), {}, func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
auto udivrem = builder.CreateCall(udivremFunc, {x, y}); |
|
||||
auto udiv = builder.CreateExtractElement(udivrem, uint64_t(0)); |
|
||||
builder.CreateRet(udiv); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
llvm::Function* createURemFunc(llvm::Type* _type, llvm::Module& _module, char const* _funcName) |
|
||||
{ |
|
||||
auto udivremFunc = _type == Type::Word ? Arith256::getUDivRem256Func(_module) : Arith256::getUDivRem512Func(_module); |
|
||||
|
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(_type, {_type, _type}, false), llvm::Function::PrivateLinkage, _funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), {}, func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
auto udivrem = builder.CreateCall(udivremFunc, {x, y}); |
|
||||
auto r = builder.CreateExtractElement(udivrem, uint64_t(1)); |
|
||||
builder.CreateRet(r); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getURem256Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.urem.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
return createURemFunc(Type::Word, _module, funcName); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getURem512Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.urem.i512"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
return createURemFunc(llvm::IntegerType::get(_module.getContext(), 512), _module, funcName); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getSDivRem256Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.sdivrem.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
auto udivremFunc = getUDivRem256Func(_module); |
|
||||
|
|
||||
auto retType = llvm::VectorType::get(Type::Word, 2); |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(retType, {Type::Word, Type::Word}, false), llvm::Function::PrivateLinkage, funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), "", func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
auto xIsNeg = builder.CreateICmpSLT(x, Constant::get(0)); |
|
||||
auto xNeg = builder.CreateSub(Constant::get(0), x); |
|
||||
auto xAbs = builder.CreateSelect(xIsNeg, xNeg, x); |
|
||||
|
|
||||
auto yIsNeg = builder.CreateICmpSLT(y, Constant::get(0)); |
|
||||
auto yNeg = builder.CreateSub(Constant::get(0), y); |
|
||||
auto yAbs = builder.CreateSelect(yIsNeg, yNeg, y); |
|
||||
|
|
||||
auto res = builder.CreateCall(udivremFunc, {xAbs, yAbs}); |
|
||||
auto qAbs = builder.CreateExtractElement(res, uint64_t(0)); |
|
||||
auto rAbs = builder.CreateExtractElement(res, 1); |
|
||||
|
|
||||
// the remainder has the same sign as dividend
|
|
||||
auto rNeg = builder.CreateSub(Constant::get(0), rAbs); |
|
||||
auto r = builder.CreateSelect(xIsNeg, rNeg, rAbs); |
|
||||
|
|
||||
auto qNeg = builder.CreateSub(Constant::get(0), qAbs); |
|
||||
auto xyOpposite = builder.CreateXor(xIsNeg, yIsNeg); |
|
||||
auto q = builder.CreateSelect(xyOpposite, qNeg, qAbs); |
|
||||
|
|
||||
auto ret = builder.CreateInsertElement(llvm::UndefValue::get(retType), q, uint64_t(0)); |
|
||||
ret = builder.CreateInsertElement(ret, r, 1); |
|
||||
builder.CreateRet(ret); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getSDiv256Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.sdiv.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
auto sdivremFunc = getSDivRem256Func(_module); |
|
||||
|
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Word, {Type::Word, Type::Word}, false), llvm::Function::PrivateLinkage, funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), {}, func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
auto sdivrem = builder.CreateCall(sdivremFunc, {x, y}); |
|
||||
auto q = builder.CreateExtractElement(sdivrem, uint64_t(0)); |
|
||||
builder.CreateRet(q); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getSRem256Func(llvm::Module& _module) |
|
||||
{ |
|
||||
static const auto funcName = "evm.srem.i256"; |
|
||||
if (auto func = _module.getFunction(funcName)) |
|
||||
return func; |
|
||||
|
|
||||
auto sdivremFunc = getSDivRem256Func(_module); |
|
||||
|
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Word, {Type::Word, Type::Word}, false), llvm::Function::PrivateLinkage, funcName, &_module); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto x = &func->getArgumentList().front(); |
|
||||
x->setName("x"); |
|
||||
auto y = x->getNextNode(); |
|
||||
y->setName("y"); |
|
||||
|
|
||||
auto bb = llvm::BasicBlock::Create(_module.getContext(), {}, func); |
|
||||
auto builder = llvm::IRBuilder<>{bb}; |
|
||||
auto sdivrem = builder.CreateCall(sdivremFunc, {x, y}); |
|
||||
auto r = builder.CreateExtractElement(sdivrem, uint64_t(1)); |
|
||||
builder.CreateRet(r); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Arith256::getExpFunc() |
|
||||
{ |
|
||||
if (!m_exp) |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {Type::Word, Type::Word}; |
|
||||
m_exp = llvm::Function::Create(llvm::FunctionType::get(Type::Word, argTypes, false), llvm::Function::PrivateLinkage, "exp", getModule()); |
|
||||
m_exp->setDoesNotThrow(); |
|
||||
m_exp->setDoesNotAccessMemory(); |
|
||||
|
|
||||
auto base = &m_exp->getArgumentList().front(); |
|
||||
base->setName("base"); |
|
||||
auto exponent = base->getNextNode(); |
|
||||
exponent->setName("exponent"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
|
|
||||
// while (e != 0) {
|
|
||||
// if (e % 2 == 1)
|
|
||||
// r *= b;
|
|
||||
// b *= b;
|
|
||||
// e /= 2;
|
|
||||
// }
|
|
||||
|
|
||||
auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), "Entry", m_exp); |
|
||||
auto headerBB = llvm::BasicBlock::Create(m_builder.getContext(), "LoopHeader", m_exp); |
|
||||
auto bodyBB = llvm::BasicBlock::Create(m_builder.getContext(), "LoopBody", m_exp); |
|
||||
auto updateBB = llvm::BasicBlock::Create(m_builder.getContext(), "ResultUpdate", m_exp); |
|
||||
auto continueBB = llvm::BasicBlock::Create(m_builder.getContext(), "Continue", m_exp); |
|
||||
auto returnBB = llvm::BasicBlock::Create(m_builder.getContext(), "Return", m_exp); |
|
||||
|
|
||||
m_builder.SetInsertPoint(entryBB); |
|
||||
m_builder.CreateBr(headerBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(headerBB); |
|
||||
auto r = m_builder.CreatePHI(Type::Word, 2, "r"); |
|
||||
auto b = m_builder.CreatePHI(Type::Word, 2, "b"); |
|
||||
auto e = m_builder.CreatePHI(Type::Word, 2, "e"); |
|
||||
auto eNonZero = m_builder.CreateICmpNE(e, Constant::get(0), "e.nonzero"); |
|
||||
m_builder.CreateCondBr(eNonZero, bodyBB, returnBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(bodyBB); |
|
||||
auto eOdd = m_builder.CreateICmpNE(m_builder.CreateAnd(e, Constant::get(1)), Constant::get(0), "e.isodd"); |
|
||||
m_builder.CreateCondBr(eOdd, updateBB, continueBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(updateBB); |
|
||||
auto mul256Func = getMulFunc(*getModule()); |
|
||||
auto r0 = createCall(mul256Func, {r, b}); |
|
||||
m_builder.CreateBr(continueBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(continueBB); |
|
||||
auto r1 = m_builder.CreatePHI(Type::Word, 2, "r1"); |
|
||||
r1->addIncoming(r, bodyBB); |
|
||||
r1->addIncoming(r0, updateBB); |
|
||||
auto b1 = createCall(mul256Func, {b, b}); |
|
||||
auto e1 = m_builder.CreateLShr(e, Constant::get(1), "e1"); |
|
||||
m_builder.CreateBr(headerBB); |
|
||||
|
|
||||
r->addIncoming(Constant::get(1), entryBB); |
|
||||
r->addIncoming(r1, continueBB); |
|
||||
b->addIncoming(base, entryBB); |
|
||||
b->addIncoming(b1, continueBB); |
|
||||
e->addIncoming(exponent, entryBB); |
|
||||
e->addIncoming(e1, continueBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(returnBB); |
|
||||
m_builder.CreateRet(r); |
|
||||
} |
|
||||
return m_exp; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Arith256::exp(llvm::Value* _arg1, llvm::Value* _arg2) |
|
||||
{ |
|
||||
// while (e != 0) {
|
|
||||
// if (e % 2 == 1)
|
|
||||
// r *= b;
|
|
||||
// b *= b;
|
|
||||
// e /= 2;
|
|
||||
// }
|
|
||||
|
|
||||
if (auto c1 = llvm::dyn_cast<llvm::ConstantInt>(_arg1)) |
|
||||
{ |
|
||||
if (auto c2 = llvm::dyn_cast<llvm::ConstantInt>(_arg2)) |
|
||||
{ |
|
||||
auto b = c1->getValue(); |
|
||||
auto e = c2->getValue(); |
|
||||
auto r = llvm::APInt{256, 1}; |
|
||||
while (e != 0) |
|
||||
{ |
|
||||
if (e[0]) |
|
||||
r *= b; |
|
||||
b *= b; |
|
||||
e = e.lshr(1); |
|
||||
} |
|
||||
return Constant::get(r); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return createCall(getExpFunc(), {_arg1, _arg2}); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
extern "C" |
|
||||
{ |
|
||||
EXPORT void debug(uint64_t a, uint64_t b, uint64_t c, uint64_t d, char z) |
|
||||
{ |
|
||||
DLOG(JIT) << "DEBUG " << std::dec << z << ": " //<< d << c << b << a
|
|
||||
<< " [" << std::hex << std::setfill('0') << std::setw(16) << d << std::setw(16) << c << std::setw(16) << b << std::setw(16) << a << "]\n"; |
|
||||
} |
|
||||
} |
|
||||
@ -1,42 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "CompilerHelper.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
class Arith256 : public CompilerHelper |
|
||||
{ |
|
||||
public: |
|
||||
Arith256(llvm::IRBuilder<>& _builder); |
|
||||
|
|
||||
llvm::Value* exp(llvm::Value* _arg1, llvm::Value* _arg2); |
|
||||
|
|
||||
void debug(llvm::Value* _value, char _c); |
|
||||
|
|
||||
static llvm::Function* getMulFunc(llvm::Module& _module); |
|
||||
static llvm::Function* getMul512Func(llvm::Module& _module); |
|
||||
static llvm::Function* getUDiv256Func(llvm::Module& _module); |
|
||||
static llvm::Function* getURem256Func(llvm::Module& _module); |
|
||||
static llvm::Function* getURem512Func(llvm::Module& _module); |
|
||||
static llvm::Function* getUDivRem256Func(llvm::Module& _module); |
|
||||
static llvm::Function* getSDiv256Func(llvm::Module& _module); |
|
||||
static llvm::Function* getSRem256Func(llvm::Module& _module); |
|
||||
static llvm::Function* getSDivRem256Func(llvm::Module& _module); |
|
||||
static llvm::Function* getUDivRem512Func(llvm::Module& _module); |
|
||||
|
|
||||
private: |
|
||||
llvm::Function* getExpFunc(); |
|
||||
|
|
||||
llvm::Function* m_exp = nullptr; |
|
||||
llvm::Function* m_debug = nullptr; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,270 +0,0 @@ |
|||||
#include "Array.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Module.h> |
|
||||
#include <llvm/IR/Function.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "RuntimeManager.h" |
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
static const auto c_reallocStep = 1; |
|
||||
|
|
||||
llvm::Value* LazyFunction::call(llvm::IRBuilder<>& _builder, std::initializer_list<llvm::Value*> const& _args, llvm::Twine const& _name) |
|
||||
{ |
|
||||
if (!m_func) |
|
||||
m_func = m_creator(); |
|
||||
|
|
||||
return _builder.CreateCall(m_func, {_args.begin(), _args.size()}, _name); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::createArrayPushFunc() |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {m_array->getType(), Type::Word}; |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "array.push", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotCapture(1); |
|
||||
|
|
||||
auto arrayPtr = &func->getArgumentList().front(); |
|
||||
arrayPtr->setName("arrayPtr"); |
|
||||
auto value = arrayPtr->getNextNode(); |
|
||||
value->setName("value"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), "Entry", func); |
|
||||
auto reallocBB = llvm::BasicBlock::Create(m_builder.getContext(), "Realloc", func); |
|
||||
auto pushBB = llvm::BasicBlock::Create(m_builder.getContext(), "Push", func); |
|
||||
|
|
||||
m_builder.SetInsertPoint(entryBB); |
|
||||
auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr"); |
|
||||
auto sizePtr = m_builder.CreateStructGEP(getType(), arrayPtr, 1, "sizePtr"); |
|
||||
auto capPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 2, "capPtr"); |
|
||||
auto data = m_builder.CreateLoad(dataPtr, "data"); |
|
||||
auto size = m_builder.CreateLoad(sizePtr, "size"); |
|
||||
auto cap = m_builder.CreateLoad(capPtr, "cap"); |
|
||||
auto reallocReq = m_builder.CreateICmpEQ(cap, size, "reallocReq"); |
|
||||
m_builder.CreateCondBr(reallocReq, reallocBB, pushBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(reallocBB); |
|
||||
auto newCap = m_builder.CreateNUWAdd(cap, m_builder.getInt64(c_reallocStep), "newCap"); |
|
||||
auto reallocSize = m_builder.CreateShl(newCap, 5, "reallocSize"); // size in bytes: newCap * 32
|
|
||||
auto bytes = m_builder.CreateBitCast(data, Type::BytePtr, "bytes"); |
|
||||
auto newBytes = m_reallocFunc.call(m_builder, {bytes, reallocSize}, "newBytes"); |
|
||||
auto newData = m_builder.CreateBitCast(newBytes, Type::WordPtr, "newData"); |
|
||||
m_builder.CreateStore(newData, dataPtr); |
|
||||
m_builder.CreateStore(newCap, capPtr); |
|
||||
m_builder.CreateBr(pushBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(pushBB); |
|
||||
auto dataPhi = m_builder.CreatePHI(Type::WordPtr, 2, "dataPhi"); |
|
||||
dataPhi->addIncoming(data, entryBB); |
|
||||
dataPhi->addIncoming(newData, reallocBB); |
|
||||
auto newElemPtr = m_builder.CreateGEP(dataPhi, size, "newElemPtr"); |
|
||||
m_builder.CreateStore(value, newElemPtr); |
|
||||
auto newSize = m_builder.CreateNUWAdd(size, m_builder.getInt64(1), "newSize"); |
|
||||
m_builder.CreateStore(newSize, sizePtr); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::createArraySetFunc() |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {m_array->getType(), Type::Size, Type::Word}; |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "array.set", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotCapture(1); |
|
||||
|
|
||||
auto arrayPtr = &func->getArgumentList().front(); |
|
||||
arrayPtr->setName("arrayPtr"); |
|
||||
auto index = arrayPtr->getNextNode(); |
|
||||
index->setName("index"); |
|
||||
auto value = index->getNextNode(); |
|
||||
value->setName("value"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func)); |
|
||||
auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr"); |
|
||||
auto data = m_builder.CreateLoad(dataPtr, "data"); |
|
||||
auto valuePtr = m_builder.CreateGEP(data, index, "valuePtr"); |
|
||||
m_builder.CreateStore(value, valuePtr); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::createArrayGetFunc() |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {m_array->getType(), Type::Size}; |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Word, argTypes, false), llvm::Function::PrivateLinkage, "array.get", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotCapture(1); |
|
||||
|
|
||||
auto arrayPtr = &func->getArgumentList().front(); |
|
||||
arrayPtr->setName("arrayPtr"); |
|
||||
auto index = arrayPtr->getNextNode(); |
|
||||
index->setName("index"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func)); |
|
||||
auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr"); |
|
||||
auto data = m_builder.CreateLoad(dataPtr, "data"); |
|
||||
auto valuePtr = m_builder.CreateGEP(data, index, "valuePtr"); |
|
||||
auto value = m_builder.CreateLoad(valuePtr, "value"); |
|
||||
m_builder.CreateRet(value); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::createGetPtrFunc() |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {m_array->getType(), Type::Size}; |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::WordPtr, argTypes, false), llvm::Function::PrivateLinkage, "array.getPtr", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotCapture(1); |
|
||||
|
|
||||
auto arrayPtr = &func->getArgumentList().front(); |
|
||||
arrayPtr->setName("arrayPtr"); |
|
||||
auto index = arrayPtr->getNextNode(); |
|
||||
index->setName("index"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func)); |
|
||||
auto dataPtr = m_builder.CreateBitCast(arrayPtr, Type::BytePtr->getPointerTo(), "dataPtr"); |
|
||||
auto data = m_builder.CreateLoad(dataPtr, "data"); |
|
||||
auto bytePtr = m_builder.CreateGEP(data, index, "bytePtr"); |
|
||||
auto wordPtr = m_builder.CreateBitCast(bytePtr, Type::WordPtr, "wordPtr"); |
|
||||
m_builder.CreateRet(wordPtr); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::createFreeFunc() |
|
||||
{ |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, m_array->getType(), false), llvm::Function::PrivateLinkage, "array.free", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotCapture(1); |
|
||||
|
|
||||
auto freeFunc = llvm::Function::Create(llvm::FunctionType::get(Type::Void, Type::BytePtr, false), llvm::Function::ExternalLinkage, "ext_free", getModule()); |
|
||||
freeFunc->setDoesNotThrow(); |
|
||||
freeFunc->setDoesNotCapture(1); |
|
||||
|
|
||||
auto arrayPtr = &func->getArgumentList().front(); |
|
||||
arrayPtr->setName("arrayPtr"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func)); |
|
||||
auto dataPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 0, "dataPtr"); |
|
||||
auto data = m_builder.CreateLoad(dataPtr, "data"); |
|
||||
auto mem = m_builder.CreateBitCast(data, Type::BytePtr, "mem"); |
|
||||
m_builder.CreateCall(freeFunc, mem); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::getReallocFunc() |
|
||||
{ |
|
||||
if (auto func = getModule()->getFunction("ext_realloc")) |
|
||||
return func; |
|
||||
|
|
||||
llvm::Type* reallocArgTypes[] = {Type::BytePtr, Type::Size}; |
|
||||
auto reallocFunc = llvm::Function::Create(llvm::FunctionType::get(Type::BytePtr, reallocArgTypes, false), llvm::Function::ExternalLinkage, "ext_realloc", getModule()); |
|
||||
reallocFunc->setDoesNotThrow(); |
|
||||
reallocFunc->setDoesNotAlias(0); |
|
||||
reallocFunc->setDoesNotCapture(1); |
|
||||
return reallocFunc; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Array::createExtendFunc() |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {m_array->getType(), Type::Size}; |
|
||||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "array.extend", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
func->setDoesNotCapture(1); |
|
||||
|
|
||||
auto arrayPtr = &func->getArgumentList().front(); |
|
||||
arrayPtr->setName("arrayPtr"); |
|
||||
auto newSize = arrayPtr->getNextNode(); |
|
||||
newSize->setName("newSize"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(m_builder.getContext(), {}, func)); |
|
||||
auto dataPtr = m_builder.CreateBitCast(arrayPtr, Type::BytePtr->getPointerTo(), "dataPtr");// TODO: Use byte* in Array
|
|
||||
auto sizePtr = m_builder.CreateStructGEP(getType(), arrayPtr, 1, "sizePtr"); |
|
||||
auto capPtr = m_builder.CreateStructGEP(getType(), arrayPtr, 2, "capPtr"); |
|
||||
auto data = m_builder.CreateLoad(dataPtr, "data"); |
|
||||
auto size = m_builder.CreateLoad(sizePtr, "size"); |
|
||||
auto extSize = m_builder.CreateNUWSub(newSize, size, "extSize"); |
|
||||
auto newData = m_reallocFunc.call(m_builder, {data, newSize}, "newData"); // TODO: Check realloc result for null
|
|
||||
auto extPtr = m_builder.CreateGEP(newData, size, "extPtr"); |
|
||||
m_builder.CreateMemSet(extPtr, m_builder.getInt8(0), extSize, 16); |
|
||||
m_builder.CreateStore(newData, dataPtr); |
|
||||
m_builder.CreateStore(newSize, sizePtr); |
|
||||
m_builder.CreateStore(newSize, capPtr); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Type* Array::getType() |
|
||||
{ |
|
||||
llvm::Type* elementTys[] = {Type::WordPtr, Type::Size, Type::Size}; |
|
||||
static auto arrayTy = llvm::StructType::create(elementTys, "Array"); |
|
||||
return arrayTy; |
|
||||
} |
|
||||
|
|
||||
Array::Array(llvm::IRBuilder<>& _builder, char const* _name) : |
|
||||
CompilerHelper(_builder) |
|
||||
{ |
|
||||
m_array = m_builder.CreateAlloca(getType(), nullptr, _name); |
|
||||
m_builder.CreateStore(llvm::ConstantAggregateZero::get(getType()), m_array); |
|
||||
} |
|
||||
|
|
||||
Array::Array(llvm::IRBuilder<>& _builder, llvm::Value* _array) : |
|
||||
CompilerHelper(_builder), |
|
||||
m_array(_array) |
|
||||
{ |
|
||||
m_builder.CreateStore(llvm::ConstantAggregateZero::get(getType()), m_array); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Array::pop(llvm::Value* _count) |
|
||||
{ |
|
||||
auto sizePtr = m_builder.CreateStructGEP(getType(), m_array, 1, "sizePtr"); |
|
||||
auto size = m_builder.CreateLoad(sizePtr, "size"); |
|
||||
auto newSize = m_builder.CreateNUWSub(size, _count, "newSize"); |
|
||||
m_builder.CreateStore(newSize, sizePtr); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Array::size(llvm::Value* _array) |
|
||||
{ |
|
||||
auto sizePtr = m_builder.CreateStructGEP(getType(), _array ? _array : m_array, 1, "sizePtr"); |
|
||||
return m_builder.CreateLoad(sizePtr, "array.size"); |
|
||||
} |
|
||||
|
|
||||
void Array::extend(llvm::Value* _arrayPtr, llvm::Value* _size) |
|
||||
{ |
|
||||
assert(_arrayPtr->getType() == m_array->getType()); |
|
||||
assert(_size->getType() == Type::Size); |
|
||||
m_extendFunc.call(m_builder, {_arrayPtr, _size}); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
extern "C" |
|
||||
{ |
|
||||
EXPORT void* ext_realloc(void* _data, size_t _size) noexcept |
|
||||
{ |
|
||||
return std::realloc(_data, _size); |
|
||||
} |
|
||||
|
|
||||
EXPORT void ext_free(void* _data) noexcept |
|
||||
{ |
|
||||
std::free(_data); |
|
||||
} |
|
||||
} |
|
||||
@ -1,72 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <functional> |
|
||||
|
|
||||
#include "CompilerHelper.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
class LazyFunction |
|
||||
{ |
|
||||
public: |
|
||||
using Creator = std::function<llvm::Function*()>; |
|
||||
|
|
||||
LazyFunction(Creator _creator) : |
|
||||
m_creator(_creator) |
|
||||
{} |
|
||||
|
|
||||
llvm::Value* call(llvm::IRBuilder<>& _builder, std::initializer_list<llvm::Value*> const& _args, llvm::Twine const& _name = ""); |
|
||||
|
|
||||
private: |
|
||||
llvm::Function* m_func = nullptr; |
|
||||
Creator m_creator; |
|
||||
}; |
|
||||
|
|
||||
class Array : public CompilerHelper |
|
||||
{ |
|
||||
public: |
|
||||
Array(llvm::IRBuilder<>& _builder, char const* _name); |
|
||||
Array(llvm::IRBuilder<>& _builder, llvm::Value* _array); |
|
||||
|
|
||||
void push(llvm::Value* _value) { m_pushFunc.call(m_builder, {m_array, _value}); } |
|
||||
void set(llvm::Value* _index, llvm::Value* _value) { m_setFunc.call(m_builder, {m_array, _index, _value}); } |
|
||||
llvm::Value* get(llvm::Value* _index) { return m_getFunc.call(m_builder, {m_array, _index}); } |
|
||||
void pop(llvm::Value* _count); |
|
||||
llvm::Value* size(llvm::Value* _array = nullptr); |
|
||||
void free() { m_freeFunc.call(m_builder, {m_array}); } |
|
||||
|
|
||||
void extend(llvm::Value* _arrayPtr, llvm::Value* _size); |
|
||||
llvm::Value* getPtr(llvm::Value* _arrayPtr, llvm::Value* _index) { return m_getPtrFunc.call(m_builder, {_arrayPtr, _index}); } |
|
||||
|
|
||||
llvm::Value* getPointerTo() const { return m_array; } |
|
||||
|
|
||||
static llvm::Type* getType(); |
|
||||
|
|
||||
private: |
|
||||
llvm::Value* m_array = nullptr; |
|
||||
|
|
||||
llvm::Function* createArrayPushFunc(); |
|
||||
llvm::Function* createArraySetFunc(); |
|
||||
llvm::Function* createArrayGetFunc(); |
|
||||
llvm::Function* createGetPtrFunc(); |
|
||||
llvm::Function* createFreeFunc(); |
|
||||
llvm::Function* createExtendFunc(); |
|
||||
llvm::Function* getReallocFunc(); |
|
||||
|
|
||||
LazyFunction m_pushFunc = {[this](){ return createArrayPushFunc(); }}; |
|
||||
LazyFunction m_setFunc = {[this](){ return createArraySetFunc(); }}; |
|
||||
LazyFunction m_getPtrFunc = {[this](){ return createGetPtrFunc(); }}; |
|
||||
LazyFunction m_getFunc = {[this](){ return createArrayGetFunc(); }}; |
|
||||
LazyFunction m_freeFunc = {[this](){ return createFreeFunc(); }}; |
|
||||
LazyFunction m_extendFunc = {[this](){ return createExtendFunc(); }}; |
|
||||
LazyFunction m_reallocFunc = {[this](){ return getReallocFunc(); }}; |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,148 +0,0 @@ |
|||||
#include "BasicBlock.h" |
|
||||
|
|
||||
#include <iostream> |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/CFG.h> |
|
||||
#include <llvm/IR/Function.h> |
|
||||
#include <llvm/IR/Instructions.h> |
|
||||
#include <llvm/IR/IRBuilder.h> |
|
||||
#include <llvm/Support/raw_os_ostream.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Type.h" |
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
BasicBlock::BasicBlock(instr_idx _firstInstrIdx, code_iterator _begin, code_iterator _end, llvm::Function* _mainFunc): |
|
||||
m_firstInstrIdx{_firstInstrIdx}, |
|
||||
m_begin(_begin), |
|
||||
m_end(_end), |
|
||||
m_llvmBB(llvm::BasicBlock::Create(_mainFunc->getContext(), {"Instr.", std::to_string(_firstInstrIdx)}, _mainFunc)) |
|
||||
{} |
|
||||
|
|
||||
LocalStack::LocalStack(Stack& _globalStack): |
|
||||
m_global(_globalStack) |
|
||||
{} |
|
||||
|
|
||||
void LocalStack::push(llvm::Value* _value) |
|
||||
{ |
|
||||
assert(_value->getType() == Type::Word); |
|
||||
m_local.push_back(_value); |
|
||||
m_maxSize = std::max(m_maxSize, size()); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* LocalStack::pop() |
|
||||
{ |
|
||||
auto item = get(0); |
|
||||
assert(!m_local.empty() || !m_input.empty()); |
|
||||
|
|
||||
if (m_local.size() > 0) |
|
||||
m_local.pop_back(); |
|
||||
else |
|
||||
++m_globalPops; |
|
||||
|
|
||||
m_minSize = std::min(m_minSize, size()); |
|
||||
return item; |
|
||||
} |
|
||||
|
|
||||
/**
|
|
||||
* Pushes a copy of _index-th element (tos is 0-th elem). |
|
||||
*/ |
|
||||
void LocalStack::dup(size_t _index) |
|
||||
{ |
|
||||
auto val = get(_index); |
|
||||
push(val); |
|
||||
} |
|
||||
|
|
||||
/**
|
|
||||
* Swaps tos with _index-th element (tos is 0-th elem). |
|
||||
* _index must be > 0. |
|
||||
*/ |
|
||||
void LocalStack::swap(size_t _index) |
|
||||
{ |
|
||||
assert(_index > 0); |
|
||||
auto val = get(_index); |
|
||||
auto tos = get(0); |
|
||||
set(_index, tos); |
|
||||
set(0, val); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* LocalStack::get(size_t _index) |
|
||||
{ |
|
||||
if (_index < m_local.size()) |
|
||||
return *(m_local.rbegin() + _index); // count from back
|
|
||||
|
|
||||
auto idx = _index - m_local.size() + m_globalPops; |
|
||||
if (idx >= m_input.size()) |
|
||||
m_input.resize(idx + 1); |
|
||||
auto& item = m_input[idx]; |
|
||||
|
|
||||
if (!item) |
|
||||
{ |
|
||||
item = m_global.get(idx); // Reach an item from global stack
|
|
||||
m_minSize = std::min(m_minSize, -static_cast<ssize_t>(idx) - 1); // and remember required stack size
|
|
||||
} |
|
||||
|
|
||||
return item; |
|
||||
} |
|
||||
|
|
||||
void LocalStack::set(size_t _index, llvm::Value* _word) |
|
||||
{ |
|
||||
if (_index < m_local.size()) |
|
||||
{ |
|
||||
*(m_local.rbegin() + _index) = _word; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
auto idx = _index - m_local.size() + m_globalPops; |
|
||||
assert(idx < m_input.size()); |
|
||||
m_input[idx] = _word; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void LocalStack::finalize(llvm::IRBuilder<>& _builder, llvm::BasicBlock& _bb) |
|
||||
{ |
|
||||
auto blockTerminator = _bb.getTerminator(); |
|
||||
if (!blockTerminator || blockTerminator->getOpcode() != llvm::Instruction::Ret) |
|
||||
{ |
|
||||
// Not needed in case of ret instruction. Ret invalidates the stack.
|
|
||||
if (blockTerminator) |
|
||||
_builder.SetInsertPoint(blockTerminator); |
|
||||
else |
|
||||
_builder.SetInsertPoint(&_bb); |
|
||||
|
|
||||
// Update items fetched from global stack ignoring the poped ones
|
|
||||
assert(m_globalPops <= m_input.size()); // pop() always does get()
|
|
||||
for (auto i = m_globalPops; i < m_input.size(); ++i) |
|
||||
{ |
|
||||
if (m_input[i]) |
|
||||
m_global.set(i, m_input[i]); |
|
||||
} |
|
||||
|
|
||||
// Add new items
|
|
||||
auto pops = m_globalPops; // Copy pops counter to keep original value
|
|
||||
for (auto& item: m_local) |
|
||||
{ |
|
||||
if (pops) // Override poped global items
|
|
||||
m_global.set(--pops, item); // using pops counter as the index
|
|
||||
else |
|
||||
m_global.push(item); |
|
||||
} |
|
||||
|
|
||||
// Pop not overriden items
|
|
||||
if (pops) |
|
||||
m_global.pop(pops); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,86 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <vector> |
|
||||
|
|
||||
#include "Common.h" |
|
||||
#include "Stack.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
using namespace evmjit; |
|
||||
using instr_idx = uint64_t; |
|
||||
|
|
||||
class LocalStack |
|
||||
{ |
|
||||
public: |
|
||||
explicit LocalStack(Stack& _globalStack); |
|
||||
LocalStack(LocalStack const&) = delete; |
|
||||
void operator=(LocalStack const&) = delete; |
|
||||
|
|
||||
/// Pushes value on stack
|
|
||||
void push(llvm::Value* _value); |
|
||||
|
|
||||
/// Pops and returns top value
|
|
||||
llvm::Value* pop(); |
|
||||
|
|
||||
/// Duplicates _index'th value on stack
|
|
||||
void dup(size_t _index); |
|
||||
|
|
||||
/// Swaps _index'th value on stack with a value on stack top.
|
|
||||
/// @param _index Index of value to be swaped. Must be > 0.
|
|
||||
void swap(size_t _index); |
|
||||
|
|
||||
ssize_t size() const { return static_cast<ssize_t>(m_local.size()) - static_cast<ssize_t>(m_globalPops); } |
|
||||
ssize_t minSize() const { return m_minSize; } |
|
||||
ssize_t maxSize() const { return m_maxSize; } |
|
||||
|
|
||||
/// Finalize local stack: check the requirements and update of the global stack.
|
|
||||
void finalize(llvm::IRBuilder<>& _builder, llvm::BasicBlock& _bb); |
|
||||
|
|
||||
private: |
|
||||
/// Gets _index'th value from top (counting from 0)
|
|
||||
llvm::Value* get(size_t _index); |
|
||||
|
|
||||
/// Sets _index'th value from top (counting from 0)
|
|
||||
void set(size_t _index, llvm::Value* _value); |
|
||||
|
|
||||
/// Items fetched from global stack. First element matches the top of the global stack.
|
|
||||
/// Can contain nulls if some items has been skipped.
|
|
||||
std::vector<llvm::Value*> m_input; |
|
||||
|
|
||||
/// Local stack items that has not been pushed to global stack. First item is just above global stack.
|
|
||||
std::vector<llvm::Value*> m_local; |
|
||||
|
|
||||
Stack& m_global; ///< Reference to global stack.
|
|
||||
|
|
||||
size_t m_globalPops = 0; ///< Number of items poped from global stack. In other words: global - local stack overlap.
|
|
||||
ssize_t m_minSize = 0; ///< Minimum reached local stack size. Can be negative.
|
|
||||
ssize_t m_maxSize = 0; ///< Maximum reached local stack size.
|
|
||||
}; |
|
||||
|
|
||||
class BasicBlock |
|
||||
{ |
|
||||
public: |
|
||||
explicit BasicBlock(instr_idx _firstInstrIdx, code_iterator _begin, code_iterator _end, llvm::Function* _mainFunc); |
|
||||
|
|
||||
llvm::BasicBlock* llvm() { return m_llvmBB; } |
|
||||
|
|
||||
instr_idx firstInstrIdx() const { return m_firstInstrIdx; } |
|
||||
code_iterator begin() const { return m_begin; } |
|
||||
code_iterator end() const { return m_end; } |
|
||||
|
|
||||
private: |
|
||||
instr_idx const m_firstInstrIdx = 0; ///< Code index of first instruction in the block
|
|
||||
code_iterator const m_begin = {}; ///< Iterator pointing code beginning of the block
|
|
||||
code_iterator const m_end = {}; ///< Iterator pointing code end of the block
|
|
||||
|
|
||||
llvm::BasicBlock* const m_llvmBB; ///< Reference to the LLVM BasicBlock
|
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,9 +0,0 @@ |
|||||
|
|
||||
#define EVMJIT_VERSION "${EVMJIT_VERSION}" |
|
||||
#define EVMJIT_VERSION_MAJOR ${EVMJIT_VERSION_MAJOR} |
|
||||
#define EVMJIT_VERSION_MINOR ${EVMJIT_VERSION_MINOR} |
|
||||
#define EVMJIT_VERSION_PATCH ${EVMJIT_VERSION_PATCH} |
|
||||
|
|
||||
#define LLVM_VERSION "${LLVM_PACKAGE_VERSION}" |
|
||||
#define LLVM_ASSERTIONS "${LLVM_ENABLE_ASSERTIONS}" |
|
||||
#define LLVM_DEBUG ${LLVM_DEBUG} |
|
||||
@ -1,58 +0,0 @@ |
|||||
set(TARGET_NAME evmjit) |
|
||||
|
|
||||
get_filename_component(EVMJIT_INCLUDE_DIR ../include ABSOLUTE) |
|
||||
|
|
||||
set(SOURCES |
|
||||
JIT.cpp ${EVMJIT_INCLUDE_DIR}/evmjit/JIT.h |
|
||||
JIT-c.cpp ${EVMJIT_INCLUDE_DIR}/evmjit/JIT-c.h |
|
||||
Arith256.cpp Arith256.h |
|
||||
Array.cpp Array.h |
|
||||
BasicBlock.cpp BasicBlock.h |
|
||||
Cache.cpp Cache.h |
|
||||
Common.h |
|
||||
Compiler.cpp Compiler.h |
|
||||
CompilerHelper.cpp CompilerHelper.h |
|
||||
Endianness.cpp Endianness.h |
|
||||
ExecStats.cpp ExecStats.h |
|
||||
Ext.cpp Ext.h |
|
||||
GasMeter.cpp GasMeter.h |
|
||||
Instruction.cpp Instruction.h |
|
||||
Memory.cpp Memory.h |
|
||||
Optimizer.cpp Optimizer.h |
|
||||
RuntimeManager.cpp RuntimeManager.h |
|
||||
Stack.cpp Stack.h |
|
||||
Type.cpp Type.h |
|
||||
Utils.cpp Utils.h |
|
||||
) |
|
||||
source_group("" FILES ${SOURCES}) |
|
||||
|
|
||||
if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC") |
|
||||
else() |
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti") |
|
||||
endif() |
|
||||
|
|
||||
if(${EVMJIT_VERSION_MAJOR} EQUAL 0) |
|
||||
set(EVMJIT_SOVERSION "0.${EVMJIT_VERSION_MINOR}") |
|
||||
else() |
|
||||
set(EVMJIT_SOVERSION ${EVMJIT_VERSION_MAJOR}) |
|
||||
endif() |
|
||||
|
|
||||
|
|
||||
string(COMPARE EQUAL "${LLVM_ENABLE_ASSERTIONS}" "ON" LLVM_DEBUG) |
|
||||
configure_file(BuildInfo.h.in ${CMAKE_CURRENT_BINARY_DIR}/gen/BuildInfo.gen.h) |
|
||||
|
|
||||
message(STATUS "EVM JIT version: ${EVMJIT_VERSION_MAJOR}.${EVMJIT_VERSION_MINOR}.${EVMJIT_VERSION_PATCH}") |
|
||||
|
|
||||
add_library(${TARGET_NAME} SHARED ${SOURCES} gen/BuildInfo.gen.h) |
|
||||
set_target_properties(${TARGET_NAME} PROPERTIES |
|
||||
VERSION ${EVMJIT_VERSION} SOVERSION ${EVMJIT_SOVERSION} |
|
||||
FOLDER "libs") |
|
||||
|
|
||||
target_include_directories(${TARGET_NAME} PUBLIC ${EVMJIT_INCLUDE_DIR}) |
|
||||
target_include_directories(${TARGET_NAME} PRIVATE ${LLVM_INCLUDE_DIRS}) |
|
||||
target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/gen) |
|
||||
target_compile_definitions(${TARGET_NAME} PRIVATE ${LLVM_DEFINITIONS}) |
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE ${LLVM_LIBS}) |
|
||||
|
|
||||
install(TARGETS ${TARGET_NAME} LIBRARY DESTINATION lib ARCHIVE DESTINATION lib RUNTIME DESTINATION bin) |
|
||||
install(DIRECTORY ${EVMJIT_INCLUDE_DIR} DESTINATION include) |
|
||||
@ -1,190 +0,0 @@ |
|||||
#include "Cache.h" |
|
||||
|
|
||||
#include <mutex> |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Module.h> |
|
||||
#include <llvm/IR/LLVMContext.h> |
|
||||
#include <llvm/IR/Instructions.h> |
|
||||
#include <llvm/ExecutionEngine/ExecutionEngine.h> |
|
||||
#include <llvm/Support/Path.h> |
|
||||
#include <llvm/Support/FileSystem.h> |
|
||||
#include <llvm/Support/raw_os_ostream.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "ExecStats.h" |
|
||||
#include "Utils.h" |
|
||||
#include "BuildInfo.gen.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
using Guard = std::lock_guard<std::mutex>; |
|
||||
std::mutex x_cacheMutex; |
|
||||
CacheMode g_mode; |
|
||||
std::unique_ptr<llvm::MemoryBuffer> g_lastObject; |
|
||||
JITListener* g_listener; |
|
||||
|
|
||||
llvm::StringRef getLibVersionStamp() |
|
||||
{ |
|
||||
return EVMJIT_VERSION; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
ObjectCache* Cache::init(CacheMode _mode, JITListener* _listener) |
|
||||
{ |
|
||||
Guard g{x_cacheMutex}; |
|
||||
|
|
||||
g_mode = _mode; |
|
||||
g_listener = _listener; |
|
||||
|
|
||||
if (g_mode == CacheMode::clear) |
|
||||
{ |
|
||||
Cache::clear(); |
|
||||
g_mode = CacheMode::off; |
|
||||
} |
|
||||
|
|
||||
if (g_mode != CacheMode::off) |
|
||||
{ |
|
||||
static ObjectCache objectCache; |
|
||||
return &objectCache; |
|
||||
} |
|
||||
return nullptr; |
|
||||
} |
|
||||
|
|
||||
void Cache::clear() |
|
||||
{ |
|
||||
Guard g{x_cacheMutex}; |
|
||||
|
|
||||
using namespace llvm::sys; |
|
||||
llvm::SmallString<256> cachePath; |
|
||||
path::system_temp_directory(false, cachePath); |
|
||||
path::append(cachePath, "evm_objs"); |
|
||||
|
|
||||
std::error_code err; |
|
||||
for (auto it = fs::directory_iterator{cachePath.str(), err}; it != fs::directory_iterator{}; it.increment(err)) |
|
||||
fs::remove(it->path()); |
|
||||
} |
|
||||
|
|
||||
void Cache::preload(llvm::ExecutionEngine& _ee, std::unordered_map<std::string, uint64_t>& _funcCache) |
|
||||
{ |
|
||||
Guard g{x_cacheMutex}; |
|
||||
|
|
||||
// TODO: Cache dir should be in one place
|
|
||||
using namespace llvm::sys; |
|
||||
llvm::SmallString<256> cachePath; |
|
||||
path::system_temp_directory(false, cachePath); |
|
||||
path::append(cachePath, "evm_objs"); |
|
||||
|
|
||||
// Disable listener
|
|
||||
auto listener = g_listener; |
|
||||
g_listener = nullptr; |
|
||||
|
|
||||
std::error_code err; |
|
||||
for (auto it = fs::directory_iterator{cachePath.str(), err}; it != fs::directory_iterator{}; it.increment(err)) |
|
||||
{ |
|
||||
auto name = it->path().substr(cachePath.size() + 1); |
|
||||
if (auto module = getObject(name)) |
|
||||
{ |
|
||||
DLOG(cache) << "Preload: " << name << "\n"; |
|
||||
_ee.addModule(std::move(module)); |
|
||||
auto addr = _ee.getFunctionAddress(name); |
|
||||
assert(addr); |
|
||||
_funcCache[std::move(name)] = addr; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
g_listener = listener; |
|
||||
} |
|
||||
|
|
||||
std::unique_ptr<llvm::Module> Cache::getObject(std::string const& id) |
|
||||
{ |
|
||||
Guard g{x_cacheMutex}; |
|
||||
|
|
||||
if (g_mode != CacheMode::on && g_mode != CacheMode::read) |
|
||||
return nullptr; |
|
||||
|
|
||||
// TODO: Disabled because is not thread-safe.
|
|
||||
//if (g_listener)
|
|
||||
// g_listener->stateChanged(ExecState::CacheLoad);
|
|
||||
|
|
||||
DLOG(cache) << id << ": search\n"; |
|
||||
if (!CHECK(!g_lastObject)) |
|
||||
g_lastObject = nullptr; |
|
||||
|
|
||||
llvm::SmallString<256> cachePath; |
|
||||
llvm::sys::path::system_temp_directory(false, cachePath); |
|
||||
llvm::sys::path::append(cachePath, "evm_objs", id); |
|
||||
|
|
||||
if (auto r = llvm::MemoryBuffer::getFile(cachePath.str(), -1, false)) |
|
||||
{ |
|
||||
auto& buf = r.get(); |
|
||||
auto expectedStamp = getLibVersionStamp(); |
|
||||
auto stampSize = expectedStamp.size(); |
|
||||
auto objStamp = buf->getBufferSize() >= stampSize ? llvm::StringRef{buf->getBufferEnd() - stampSize, stampSize} : llvm::StringRef{}; |
|
||||
if (objStamp == expectedStamp) |
|
||||
g_lastObject = llvm::MemoryBuffer::getMemBufferCopy(r.get()->getBuffer()); |
|
||||
else |
|
||||
DLOG(cache) << "Unmatched version: " << objStamp.str() << ", expected " << expectedStamp.str() << "\n"; |
|
||||
} |
|
||||
else if (r.getError() != std::make_error_code(std::errc::no_such_file_or_directory)) |
|
||||
DLOG(cache) << r.getError().message(); // TODO: Add warning log
|
|
||||
|
|
||||
if (g_lastObject) // if object found create fake module
|
|
||||
{ |
|
||||
DLOG(cache) << id << ": found\n"; |
|
||||
auto&& context = llvm::getGlobalContext(); |
|
||||
auto module = std::unique_ptr<llvm::Module>(new llvm::Module(id, context)); |
|
||||
auto mainFuncType = llvm::FunctionType::get(llvm::Type::getVoidTy(context), {}, false); |
|
||||
auto mainFunc = llvm::Function::Create(mainFuncType, llvm::Function::ExternalLinkage, id, module.get()); |
|
||||
auto bb = llvm::BasicBlock::Create(context, {}, mainFunc); |
|
||||
bb->getInstList().push_back(new llvm::UnreachableInst{context}); |
|
||||
return module; |
|
||||
} |
|
||||
DLOG(cache) << id << ": not found\n"; |
|
||||
return nullptr; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void ObjectCache::notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBufferRef _object) |
|
||||
{ |
|
||||
Guard g{x_cacheMutex}; |
|
||||
|
|
||||
// Only in "on" and "write" mode
|
|
||||
if (g_mode != CacheMode::on && g_mode != CacheMode::write) |
|
||||
return; |
|
||||
|
|
||||
// TODO: Disabled because is not thread-safe.
|
|
||||
// if (g_listener)
|
|
||||
// g_listener->stateChanged(ExecState::CacheWrite);
|
|
||||
|
|
||||
auto&& id = _module->getModuleIdentifier(); |
|
||||
llvm::SmallString<256> cachePath; |
|
||||
llvm::sys::path::system_temp_directory(false, cachePath); |
|
||||
llvm::sys::path::append(cachePath, "evm_objs"); |
|
||||
|
|
||||
if (llvm::sys::fs::create_directory(cachePath.str())) |
|
||||
DLOG(cache) << "Cannot create cache dir " << cachePath.str().str() << "\n"; |
|
||||
|
|
||||
llvm::sys::path::append(cachePath, id); |
|
||||
|
|
||||
DLOG(cache) << id << ": write\n"; |
|
||||
std::error_code error; |
|
||||
llvm::raw_fd_ostream cacheFile(cachePath.c_str(), error, llvm::sys::fs::F_None); |
|
||||
cacheFile << _object.getBuffer() << getLibVersionStamp(); |
|
||||
} |
|
||||
|
|
||||
std::unique_ptr<llvm::MemoryBuffer> ObjectCache::getObject(llvm::Module const* _module) |
|
||||
{ |
|
||||
Guard g{x_cacheMutex}; |
|
||||
|
|
||||
DLOG(cache) << _module->getModuleIdentifier() << ": use\n"; |
|
||||
return std::move(g_lastObject); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,59 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <memory> |
|
||||
#include <unordered_map> |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/ExecutionEngine/ObjectCache.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
namespace llvm |
|
||||
{ |
|
||||
class ExecutionEngine; |
|
||||
} |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
class JITListener; |
|
||||
|
|
||||
enum class CacheMode |
|
||||
{ |
|
||||
on, |
|
||||
off, |
|
||||
read, |
|
||||
write, |
|
||||
clear, |
|
||||
preload |
|
||||
}; |
|
||||
|
|
||||
class ObjectCache : public llvm::ObjectCache |
|
||||
{ |
|
||||
public: |
|
||||
/// notifyObjectCompiled - Provides a pointer to compiled code for Module M.
|
|
||||
virtual void notifyObjectCompiled(llvm::Module const* _module, llvm::MemoryBufferRef _object) final override; |
|
||||
|
|
||||
/// getObjectCopy - Returns a pointer to a newly allocated MemoryBuffer that
|
|
||||
/// contains the object which corresponds with Module M, or 0 if an object is
|
|
||||
/// not available. The caller owns both the MemoryBuffer returned by this
|
|
||||
/// and the memory it references.
|
|
||||
virtual std::unique_ptr<llvm::MemoryBuffer> getObject(llvm::Module const* _module) final override; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
class Cache |
|
||||
{ |
|
||||
public: |
|
||||
static ObjectCache* init(CacheMode _mode, JITListener* _listener); |
|
||||
static std::unique_ptr<llvm::Module> getObject(std::string const& id); |
|
||||
|
|
||||
/// Clears cache storage
|
|
||||
static void clear(); |
|
||||
|
|
||||
/// Loads all available cached objects to ExecutionEngine
|
|
||||
static void preload(llvm::ExecutionEngine& _ee, std::unordered_map<std::string, uint64_t>& _funcCache); |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,16 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <cstdint> |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
using byte = uint8_t; |
|
||||
using code_iterator = byte const*; |
|
||||
|
|
||||
#define UNTESTED assert(false) |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,800 +0,0 @@ |
|||||
#include "Compiler.h" |
|
||||
|
|
||||
#include <functional> |
|
||||
#include <fstream> |
|
||||
#include <chrono> |
|
||||
#include <sstream> |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/CFG.h> |
|
||||
#include <llvm/IR/Module.h> |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Instruction.h" |
|
||||
#include "Type.h" |
|
||||
#include "Memory.h" |
|
||||
#include "Stack.h" |
|
||||
#include "Ext.h" |
|
||||
#include "GasMeter.h" |
|
||||
#include "Utils.h" |
|
||||
#include "Endianness.h" |
|
||||
#include "Arith256.h" |
|
||||
#include "RuntimeManager.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
static const auto c_destIdxLabel = "destIdx"; |
|
||||
|
|
||||
Compiler::Compiler(Options const& _options): |
|
||||
m_options(_options), |
|
||||
m_builder(llvm::getGlobalContext()) |
|
||||
{ |
|
||||
Type::init(m_builder.getContext()); |
|
||||
} |
|
||||
|
|
||||
std::vector<BasicBlock> Compiler::createBasicBlocks(code_iterator _codeBegin, code_iterator _codeEnd, llvm::SwitchInst& _jumpTable) |
|
||||
{ |
|
||||
/// Helper function that skips push data and finds next iterator (can be the end)
|
|
||||
auto skipPushDataAndGetNext = [](code_iterator _curr, code_iterator _end) |
|
||||
{ |
|
||||
static const auto push1 = static_cast<size_t>(Instruction::PUSH1); |
|
||||
static const auto push32 = static_cast<size_t>(Instruction::PUSH32); |
|
||||
size_t offset = 1; |
|
||||
if (*_curr >= push1 && *_curr <= push32) |
|
||||
offset += std::min<size_t>(*_curr - push1 + 1, (_end - _curr) - 1); |
|
||||
return _curr + offset; |
|
||||
}; |
|
||||
|
|
||||
// Skip all STOPs in the end
|
|
||||
for (; _codeEnd != _codeBegin; --_codeEnd) |
|
||||
if (*(_codeEnd - 1) != static_cast<byte>(Instruction::STOP)) |
|
||||
break; |
|
||||
|
|
||||
std::vector<BasicBlock> blocks; |
|
||||
|
|
||||
auto begin = _codeBegin; // begin of current block
|
|
||||
for (auto curr = begin, next = begin; curr != _codeEnd; curr = next) |
|
||||
{ |
|
||||
next = skipPushDataAndGetNext(curr, _codeEnd); |
|
||||
|
|
||||
bool isEnd = false; |
|
||||
switch (Instruction(*curr)) |
|
||||
{ |
|
||||
case Instruction::JUMP: |
|
||||
case Instruction::JUMPI: |
|
||||
case Instruction::RETURN: |
|
||||
case Instruction::STOP: |
|
||||
case Instruction::SUICIDE: |
|
||||
isEnd = true; |
|
||||
break; |
|
||||
|
|
||||
default: |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
assert(next <= _codeEnd); |
|
||||
if (next == _codeEnd || Instruction(*next) == Instruction::JUMPDEST) |
|
||||
isEnd = true; |
|
||||
|
|
||||
if (isEnd) |
|
||||
{ |
|
||||
auto beginIdx = begin - _codeBegin; |
|
||||
blocks.emplace_back(beginIdx, begin, next, m_mainFunc); |
|
||||
if (Instruction(*begin) == Instruction::JUMPDEST) |
|
||||
_jumpTable.addCase(Constant::get(beginIdx), blocks.back().llvm()); |
|
||||
begin = next; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return blocks; |
|
||||
} |
|
||||
|
|
||||
void Compiler::resolveJumps() |
|
||||
{ |
|
||||
// Iterate through all EVM instructions blocks (skip first 4 - special blocks).
|
|
||||
for (auto it = std::next(m_mainFunc->begin(), 4); it != m_mainFunc->end(); ++it) |
|
||||
{ |
|
||||
auto jumpTable = llvm::cast<llvm::SwitchInst>(m_jumpTableBB->getTerminator()); |
|
||||
auto jumpTableInput = llvm::cast<llvm::PHINode>(m_jumpTableBB->begin()); |
|
||||
auto nextBlock = it->getNextNode() != m_mainFunc->end() ? it->getNextNode() : m_stopBB; |
|
||||
auto term = it->getTerminator(); |
|
||||
|
|
||||
if (!term) // Block may have no terminator if the next instruction is a jump destination.
|
|
||||
llvm::IRBuilder<>{it}.CreateBr(nextBlock); |
|
||||
else if (auto jump = llvm::dyn_cast<llvm::BranchInst>(term)) |
|
||||
if (jump->getSuccessor(0) == m_jumpTableBB) |
|
||||
{ |
|
||||
auto destIdx = llvm::cast<llvm::ValueAsMetadata>(jump->getMetadata(c_destIdxLabel)->getOperand(0))->getValue(); |
|
||||
if (auto constant = llvm::dyn_cast<llvm::ConstantInt>(destIdx)) |
|
||||
{ |
|
||||
// If destination index is a constant do direct jump to the destination block.
|
|
||||
auto bb = jumpTable->findCaseValue(constant).getCaseSuccessor(); |
|
||||
jump->setSuccessor(0, bb); |
|
||||
} |
|
||||
else |
|
||||
jumpTableInput->addIncoming(destIdx, it); // Fill up PHI node
|
|
||||
|
|
||||
if (jump->isConditional()) |
|
||||
jump->setSuccessor(1, nextBlock); // Set next block for conditional jumps
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
std::unique_ptr<llvm::Module> Compiler::compile(code_iterator _begin, code_iterator _end, std::string const& _id) |
|
||||
{ |
|
||||
auto module = std::unique_ptr<llvm::Module>(new llvm::Module(_id, m_builder.getContext())); |
|
||||
|
|
||||
// Create main function
|
|
||||
auto mainFuncType = llvm::FunctionType::get(Type::MainReturn, Type::RuntimePtr, false); |
|
||||
m_mainFunc = llvm::Function::Create(mainFuncType, llvm::Function::ExternalLinkage, _id, module.get()); |
|
||||
m_mainFunc->getArgumentList().front().setName("rt"); |
|
||||
|
|
||||
// Create entry basic block
|
|
||||
auto entryBlock = llvm::BasicBlock::Create(m_builder.getContext(), {}, m_mainFunc); |
|
||||
|
|
||||
m_stopBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "Stop", m_mainFunc); |
|
||||
m_abortBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "Abort", m_mainFunc); |
|
||||
m_jumpTableBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "JumpTable", m_mainFunc); |
|
||||
m_builder.SetInsertPoint(m_jumpTableBB); |
|
||||
auto target = m_builder.CreatePHI(Type::Word, 16, "target"); |
|
||||
auto& jumpTable = *m_builder.CreateSwitch(target, m_abortBB); |
|
||||
|
|
||||
m_builder.SetInsertPoint(entryBlock); |
|
||||
|
|
||||
auto blocks = createBasicBlocks(_begin, _end, jumpTable); |
|
||||
|
|
||||
// Init runtime structures.
|
|
||||
RuntimeManager runtimeManager(m_builder, _begin, _end); |
|
||||
GasMeter gasMeter(m_builder, runtimeManager); |
|
||||
Memory memory(runtimeManager, gasMeter); |
|
||||
Ext ext(runtimeManager, memory); |
|
||||
Stack stack(m_builder); |
|
||||
runtimeManager.setStack(stack); // Runtime Manager will free stack memory
|
|
||||
Arith256 arith(m_builder); |
|
||||
|
|
||||
auto jmpBufWords = m_builder.CreateAlloca(Type::BytePtr, m_builder.getInt64(3), "jmpBuf.words"); |
|
||||
auto frameaddress = llvm::Intrinsic::getDeclaration(module.get(), llvm::Intrinsic::frameaddress); |
|
||||
auto fp = m_builder.CreateCall(frameaddress, m_builder.getInt32(0), "fp"); |
|
||||
m_builder.CreateStore(fp, jmpBufWords); |
|
||||
auto stacksave = llvm::Intrinsic::getDeclaration(module.get(), llvm::Intrinsic::stacksave); |
|
||||
auto sp = m_builder.CreateCall(stacksave, {}, "sp"); |
|
||||
auto jmpBufSp = m_builder.CreateConstInBoundsGEP1_64(jmpBufWords, 2, "jmpBuf.sp"); |
|
||||
m_builder.CreateStore(sp, jmpBufSp); |
|
||||
auto setjmp = llvm::Intrinsic::getDeclaration(module.get(), llvm::Intrinsic::eh_sjlj_setjmp); |
|
||||
auto jmpBuf = m_builder.CreateBitCast(jmpBufWords, Type::BytePtr, "jmpBuf"); |
|
||||
auto r = m_builder.CreateCall(setjmp, jmpBuf); |
|
||||
auto normalFlow = m_builder.CreateICmpEQ(r, m_builder.getInt32(0)); |
|
||||
runtimeManager.setJmpBuf(jmpBuf); |
|
||||
|
|
||||
auto firstBB = blocks.empty() ? m_stopBB : blocks.front().llvm(); |
|
||||
m_builder.CreateCondBr(normalFlow, firstBB, m_abortBB, Type::expectTrue); |
|
||||
|
|
||||
for (auto& block: blocks) |
|
||||
compileBasicBlock(block, runtimeManager, arith, memory, ext, gasMeter, stack); |
|
||||
|
|
||||
// Code for special blocks:
|
|
||||
m_builder.SetInsertPoint(m_stopBB); |
|
||||
runtimeManager.exit(ReturnCode::Stop); |
|
||||
|
|
||||
m_builder.SetInsertPoint(m_abortBB); |
|
||||
runtimeManager.exit(ReturnCode::OutOfGas); |
|
||||
|
|
||||
resolveJumps(); |
|
||||
|
|
||||
return module; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void Compiler::compileBasicBlock(BasicBlock& _basicBlock, RuntimeManager& _runtimeManager, |
|
||||
Arith256& _arith, Memory& _memory, Ext& _ext, GasMeter& _gasMeter, Stack& _globalStack) |
|
||||
{ |
|
||||
m_builder.SetInsertPoint(_basicBlock.llvm()); |
|
||||
LocalStack stack{_globalStack}; |
|
||||
|
|
||||
for (auto it = _basicBlock.begin(); it != _basicBlock.end(); ++it) |
|
||||
{ |
|
||||
auto inst = Instruction(*it); |
|
||||
|
|
||||
_gasMeter.count(inst); |
|
||||
|
|
||||
switch (inst) |
|
||||
{ |
|
||||
|
|
||||
case Instruction::ADD: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto result = m_builder.CreateAdd(lhs, rhs); |
|
||||
stack.push(result); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SUB: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto result = m_builder.CreateSub(lhs, rhs); |
|
||||
stack.push(result); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MUL: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res = m_builder.CreateMul(lhs, rhs); |
|
||||
stack.push(res); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::DIV: |
|
||||
{ |
|
||||
auto d = stack.pop(); |
|
||||
auto n = stack.pop(); |
|
||||
auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0)); |
|
||||
n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
|
|
||||
auto r = m_builder.CreateUDiv(d, n); |
|
||||
r = m_builder.CreateSelect(divByZero, Constant::get(0), r); |
|
||||
stack.push(r); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SDIV: |
|
||||
{ |
|
||||
auto d = stack.pop(); |
|
||||
auto n = stack.pop(); |
|
||||
auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0)); |
|
||||
auto divByMinusOne = m_builder.CreateICmpEQ(n, Constant::get(-1)); |
|
||||
n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
|
|
||||
auto r = m_builder.CreateSDiv(d, n); |
|
||||
r = m_builder.CreateSelect(divByZero, Constant::get(0), r); |
|
||||
auto dNeg = m_builder.CreateSub(Constant::get(0), d); |
|
||||
r = m_builder.CreateSelect(divByMinusOne, dNeg, r); // protect against undef i256.min / -1
|
|
||||
stack.push(r); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MOD: |
|
||||
{ |
|
||||
auto d = stack.pop(); |
|
||||
auto n = stack.pop(); |
|
||||
auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0)); |
|
||||
n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
|
|
||||
auto r = m_builder.CreateURem(d, n); |
|
||||
r = m_builder.CreateSelect(divByZero, Constant::get(0), r); |
|
||||
stack.push(r); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SMOD: |
|
||||
{ |
|
||||
auto d = stack.pop(); |
|
||||
auto n = stack.pop(); |
|
||||
auto divByZero = m_builder.CreateICmpEQ(n, Constant::get(0)); |
|
||||
auto divByMinusOne = m_builder.CreateICmpEQ(n, Constant::get(-1)); |
|
||||
n = m_builder.CreateSelect(divByZero, Constant::get(1), n); // protect against hardware signal
|
|
||||
auto r = m_builder.CreateSRem(d, n); |
|
||||
r = m_builder.CreateSelect(divByZero, Constant::get(0), r); |
|
||||
r = m_builder.CreateSelect(divByMinusOne, Constant::get(0), r); // protect against undef i256.min / -1
|
|
||||
stack.push(r); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::ADDMOD: |
|
||||
{ |
|
||||
auto i512Ty = m_builder.getIntNTy(512); |
|
||||
auto a = stack.pop(); |
|
||||
auto b = stack.pop(); |
|
||||
auto m = stack.pop(); |
|
||||
auto divByZero = m_builder.CreateICmpEQ(m, Constant::get(0)); |
|
||||
a = m_builder.CreateZExt(a, i512Ty); |
|
||||
b = m_builder.CreateZExt(b, i512Ty); |
|
||||
m = m_builder.CreateZExt(m, i512Ty); |
|
||||
auto s = m_builder.CreateNUWAdd(a, b); |
|
||||
s = m_builder.CreateURem(s, m); |
|
||||
s = m_builder.CreateTrunc(s, Type::Word); |
|
||||
s = m_builder.CreateSelect(divByZero, Constant::get(0), s); |
|
||||
stack.push(s); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MULMOD: |
|
||||
{ |
|
||||
auto i512Ty = m_builder.getIntNTy(512); |
|
||||
auto a = stack.pop(); |
|
||||
auto b = stack.pop(); |
|
||||
auto m = stack.pop(); |
|
||||
auto divByZero = m_builder.CreateICmpEQ(m, Constant::get(0)); |
|
||||
m = m_builder.CreateZExt(m, i512Ty); |
|
||||
// TODO: Add support for i256 x i256 -> i512 in LowerEVM pass
|
|
||||
llvm::Value* p = m_builder.CreateCall(Arith256::getMul512Func(*_basicBlock.llvm()->getParent()->getParent()), {a, b}); |
|
||||
p = m_builder.CreateURem(p, m); |
|
||||
p = m_builder.CreateTrunc(p, Type::Word); |
|
||||
p = m_builder.CreateSelect(divByZero, Constant::get(0), p); |
|
||||
stack.push(p); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::EXP: |
|
||||
{ |
|
||||
auto base = stack.pop(); |
|
||||
auto exponent = stack.pop(); |
|
||||
_gasMeter.countExp(exponent); |
|
||||
auto ret = _arith.exp(base, exponent); |
|
||||
stack.push(ret); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::NOT: |
|
||||
{ |
|
||||
auto value = stack.pop(); |
|
||||
auto ret = m_builder.CreateXor(value, Constant::get(-1), "bnot"); |
|
||||
stack.push(ret); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::LT: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res1 = m_builder.CreateICmpULT(lhs, rhs); |
|
||||
auto res256 = m_builder.CreateZExt(res1, Type::Word); |
|
||||
stack.push(res256); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::GT: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res1 = m_builder.CreateICmpUGT(lhs, rhs); |
|
||||
auto res256 = m_builder.CreateZExt(res1, Type::Word); |
|
||||
stack.push(res256); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SLT: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res1 = m_builder.CreateICmpSLT(lhs, rhs); |
|
||||
auto res256 = m_builder.CreateZExt(res1, Type::Word); |
|
||||
stack.push(res256); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SGT: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res1 = m_builder.CreateICmpSGT(lhs, rhs); |
|
||||
auto res256 = m_builder.CreateZExt(res1, Type::Word); |
|
||||
stack.push(res256); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::EQ: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res1 = m_builder.CreateICmpEQ(lhs, rhs); |
|
||||
auto res256 = m_builder.CreateZExt(res1, Type::Word); |
|
||||
stack.push(res256); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::ISZERO: |
|
||||
{ |
|
||||
auto top = stack.pop(); |
|
||||
auto iszero = m_builder.CreateICmpEQ(top, Constant::get(0), "iszero"); |
|
||||
auto result = m_builder.CreateZExt(iszero, Type::Word); |
|
||||
stack.push(result); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::AND: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res = m_builder.CreateAnd(lhs, rhs); |
|
||||
stack.push(res); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::OR: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res = m_builder.CreateOr(lhs, rhs); |
|
||||
stack.push(res); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::XOR: |
|
||||
{ |
|
||||
auto lhs = stack.pop(); |
|
||||
auto rhs = stack.pop(); |
|
||||
auto res = m_builder.CreateXor(lhs, rhs); |
|
||||
stack.push(res); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::BYTE: |
|
||||
{ |
|
||||
const auto idx = stack.pop(); |
|
||||
auto value = Endianness::toBE(m_builder, stack.pop()); |
|
||||
|
|
||||
auto idxValid = m_builder.CreateICmpULT(idx, Constant::get(32), "idxValid"); |
|
||||
auto bytes = m_builder.CreateBitCast(value, llvm::VectorType::get(Type::Byte, 32), "bytes"); |
|
||||
// TODO: Workaround for LLVM bug. Using big value of index causes invalid memory access.
|
|
||||
auto safeIdx = m_builder.CreateTrunc(idx, m_builder.getIntNTy(5)); |
|
||||
// TODO: Workaround for LLVM bug. DAG Builder used sext on index instead of zext
|
|
||||
safeIdx = m_builder.CreateZExt(safeIdx, Type::Size); |
|
||||
auto byte = m_builder.CreateExtractElement(bytes, safeIdx, "byte"); |
|
||||
value = m_builder.CreateZExt(byte, Type::Word); |
|
||||
value = m_builder.CreateSelect(idxValid, value, Constant::get(0)); |
|
||||
stack.push(value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SIGNEXTEND: |
|
||||
{ |
|
||||
auto idx = stack.pop(); |
|
||||
auto word = stack.pop(); |
|
||||
|
|
||||
auto k32_ = m_builder.CreateTrunc(idx, m_builder.getIntNTy(5), "k_32"); |
|
||||
auto k32 = m_builder.CreateZExt(k32_, Type::Size); |
|
||||
auto k32x8 = m_builder.CreateMul(k32, m_builder.getInt64(8), "kx8"); |
|
||||
|
|
||||
// test for word >> (k * 8 + 7)
|
|
||||
auto bitpos = m_builder.CreateAdd(k32x8, m_builder.getInt64(7), "bitpos"); |
|
||||
auto bitposEx = m_builder.CreateZExt(bitpos, Type::Word); |
|
||||
auto bitval = m_builder.CreateLShr(word, bitposEx, "bitval"); |
|
||||
auto bittest = m_builder.CreateTrunc(bitval, Type::Bool, "bittest"); |
|
||||
|
|
||||
auto mask_ = m_builder.CreateShl(Constant::get(1), bitposEx); |
|
||||
auto mask = m_builder.CreateSub(mask_, Constant::get(1), "mask"); |
|
||||
|
|
||||
auto negmask = m_builder.CreateXor(mask, llvm::ConstantInt::getAllOnesValue(Type::Word), "negmask"); |
|
||||
auto val1 = m_builder.CreateOr(word, negmask); |
|
||||
auto val0 = m_builder.CreateAnd(word, mask); |
|
||||
|
|
||||
auto kInRange = m_builder.CreateICmpULE(idx, llvm::ConstantInt::get(Type::Word, 30)); |
|
||||
auto result = m_builder.CreateSelect(kInRange, |
|
||||
m_builder.CreateSelect(bittest, val1, val0), |
|
||||
word); |
|
||||
stack.push(result); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SHA3: |
|
||||
{ |
|
||||
auto inOff = stack.pop(); |
|
||||
auto inSize = stack.pop(); |
|
||||
_memory.require(inOff, inSize); |
|
||||
_gasMeter.countSha3Data(inSize); |
|
||||
auto hash = _ext.sha3(inOff, inSize); |
|
||||
stack.push(hash); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::POP: |
|
||||
{ |
|
||||
stack.pop(); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::ANY_PUSH: |
|
||||
{ |
|
||||
auto value = readPushData(it, _basicBlock.end()); |
|
||||
stack.push(Constant::get(value)); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::ANY_DUP: |
|
||||
{ |
|
||||
auto index = static_cast<size_t>(inst) - static_cast<size_t>(Instruction::DUP1); |
|
||||
stack.dup(index); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::ANY_SWAP: |
|
||||
{ |
|
||||
auto index = static_cast<size_t>(inst) - static_cast<size_t>(Instruction::SWAP1) + 1; |
|
||||
stack.swap(index); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MLOAD: |
|
||||
{ |
|
||||
auto addr = stack.pop(); |
|
||||
auto word = _memory.loadWord(addr); |
|
||||
stack.push(word); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MSTORE: |
|
||||
{ |
|
||||
auto addr = stack.pop(); |
|
||||
auto word = stack.pop(); |
|
||||
_memory.storeWord(addr, word); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MSTORE8: |
|
||||
{ |
|
||||
auto addr = stack.pop(); |
|
||||
auto word = stack.pop(); |
|
||||
_memory.storeByte(addr, word); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::MSIZE: |
|
||||
{ |
|
||||
auto word = _memory.getSize(); |
|
||||
stack.push(word); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SLOAD: |
|
||||
{ |
|
||||
auto index = stack.pop(); |
|
||||
auto value = _ext.sload(index); |
|
||||
stack.push(value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SSTORE: |
|
||||
{ |
|
||||
auto index = stack.pop(); |
|
||||
auto value = stack.pop(); |
|
||||
_gasMeter.countSStore(_ext, index, value); |
|
||||
_ext.sstore(index, value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::JUMP: |
|
||||
case Instruction::JUMPI: |
|
||||
{ |
|
||||
auto destIdx = llvm::MDNode::get(m_builder.getContext(), llvm::ValueAsMetadata::get(stack.pop())); |
|
||||
|
|
||||
// Create branch instruction, initially to jump table.
|
|
||||
// Destination will be optimized with direct jump during jump resolving if destination index is a constant.
|
|
||||
auto jumpInst = (inst == Instruction::JUMP) ? |
|
||||
m_builder.CreateBr(m_jumpTableBB) : |
|
||||
m_builder.CreateCondBr(m_builder.CreateICmpNE(stack.pop(), Constant::get(0), "jump.check"), m_jumpTableBB, nullptr); |
|
||||
|
|
||||
// Attach medatada to branch instruction with information about destination index.
|
|
||||
jumpInst->setMetadata(c_destIdxLabel, destIdx); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::JUMPDEST: |
|
||||
{ |
|
||||
// Nothing to do
|
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::PC: |
|
||||
{ |
|
||||
auto value = Constant::get(it - _basicBlock.begin() + _basicBlock.firstInstrIdx()); |
|
||||
stack.push(value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::GAS: |
|
||||
{ |
|
||||
_gasMeter.commitCostBlock(); |
|
||||
stack.push(m_builder.CreateZExt(_runtimeManager.getGas(), Type::Word)); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::ADDRESS: |
|
||||
case Instruction::CALLER: |
|
||||
case Instruction::ORIGIN: |
|
||||
case Instruction::CALLVALUE: |
|
||||
case Instruction::GASPRICE: |
|
||||
case Instruction::COINBASE: |
|
||||
case Instruction::DIFFICULTY: |
|
||||
case Instruction::GASLIMIT: |
|
||||
case Instruction::NUMBER: |
|
||||
case Instruction::TIMESTAMP: |
|
||||
{ |
|
||||
// Pushes an element of runtime data on stack
|
|
||||
auto value = _runtimeManager.get(inst); |
|
||||
value = m_builder.CreateZExt(value, Type::Word); |
|
||||
stack.push(value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CODESIZE: |
|
||||
stack.push(_runtimeManager.getCodeSize()); |
|
||||
break; |
|
||||
|
|
||||
case Instruction::CALLDATASIZE: |
|
||||
stack.push(_runtimeManager.getCallDataSize()); |
|
||||
break; |
|
||||
|
|
||||
case Instruction::BLOCKHASH: |
|
||||
{ |
|
||||
auto number = stack.pop(); |
|
||||
auto hash = _ext.blockHash(number); |
|
||||
stack.push(hash); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::BALANCE: |
|
||||
{ |
|
||||
auto address = stack.pop(); |
|
||||
auto value = _ext.balance(address); |
|
||||
stack.push(value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::EXTCODESIZE: |
|
||||
{ |
|
||||
auto addr = stack.pop(); |
|
||||
auto codeRef = _ext.extcode(addr); |
|
||||
stack.push(codeRef.size); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CALLDATACOPY: |
|
||||
{ |
|
||||
auto destMemIdx = stack.pop(); |
|
||||
auto srcIdx = stack.pop(); |
|
||||
auto reqBytes = stack.pop(); |
|
||||
|
|
||||
auto srcPtr = _runtimeManager.getCallData(); |
|
||||
auto srcSize = _runtimeManager.getCallDataSize(); |
|
||||
|
|
||||
_memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CODECOPY: |
|
||||
{ |
|
||||
auto destMemIdx = stack.pop(); |
|
||||
auto srcIdx = stack.pop(); |
|
||||
auto reqBytes = stack.pop(); |
|
||||
|
|
||||
auto srcPtr = _runtimeManager.getCode(); // TODO: Code & its size are constants, feature #80814234
|
|
||||
auto srcSize = _runtimeManager.getCodeSize(); |
|
||||
|
|
||||
_memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::EXTCODECOPY: |
|
||||
{ |
|
||||
auto addr = stack.pop(); |
|
||||
auto destMemIdx = stack.pop(); |
|
||||
auto srcIdx = stack.pop(); |
|
||||
auto reqBytes = stack.pop(); |
|
||||
|
|
||||
auto codeRef = _ext.extcode(addr); |
|
||||
|
|
||||
_memory.copyBytes(codeRef.ptr, codeRef.size, srcIdx, destMemIdx, reqBytes); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CALLDATALOAD: |
|
||||
{ |
|
||||
auto idx = stack.pop(); |
|
||||
auto value = _ext.calldataload(idx); |
|
||||
stack.push(value); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CREATE: |
|
||||
{ |
|
||||
auto endowment = stack.pop(); |
|
||||
auto initOff = stack.pop(); |
|
||||
auto initSize = stack.pop(); |
|
||||
_memory.require(initOff, initSize); |
|
||||
|
|
||||
_gasMeter.commitCostBlock(); |
|
||||
auto address = _ext.create(endowment, initOff, initSize); |
|
||||
stack.push(address); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CALL: |
|
||||
case Instruction::CALLCODE: |
|
||||
{ |
|
||||
auto callGas = stack.pop(); |
|
||||
auto codeAddress = stack.pop(); |
|
||||
auto value = stack.pop(); |
|
||||
auto inOff = stack.pop(); |
|
||||
auto inSize = stack.pop(); |
|
||||
auto outOff = stack.pop(); |
|
||||
auto outSize = stack.pop(); |
|
||||
|
|
||||
_gasMeter.commitCostBlock(); |
|
||||
|
|
||||
// Require memory for in and out buffers
|
|
||||
_memory.require(outOff, outSize); // Out buffer first as we guess it will be after the in one
|
|
||||
_memory.require(inOff, inSize); |
|
||||
|
|
||||
auto receiveAddress = codeAddress; |
|
||||
if (inst == Instruction::CALLCODE) |
|
||||
receiveAddress = _runtimeManager.get(RuntimeData::Address); |
|
||||
|
|
||||
auto ret = _ext.call(callGas, receiveAddress, value, inOff, inSize, outOff, outSize, codeAddress); |
|
||||
_gasMeter.count(m_builder.getInt64(0), _runtimeManager.getJmpBuf(), _runtimeManager.getGasPtr()); |
|
||||
stack.push(ret); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::RETURN: |
|
||||
{ |
|
||||
auto index = stack.pop(); |
|
||||
auto size = stack.pop(); |
|
||||
|
|
||||
_memory.require(index, size); |
|
||||
_runtimeManager.registerReturnData(index, size); |
|
||||
|
|
||||
_runtimeManager.exit(ReturnCode::Return); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
case Instruction::SUICIDE: |
|
||||
{ |
|
||||
_runtimeManager.registerSuicide(stack.pop()); |
|
||||
_runtimeManager.exit(ReturnCode::Suicide); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
case Instruction::STOP: |
|
||||
{ |
|
||||
m_builder.CreateBr(m_stopBB); |
|
||||
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); |
|
||||
|
|
||||
// This will commit the current cost block
|
|
||||
_gasMeter.countLogData(numBytes); |
|
||||
|
|
||||
std::array<llvm::Value*, 4> topics{{}}; |
|
||||
auto numTopics = static_cast<size_t>(inst) - static_cast<size_t>(Instruction::LOG0); |
|
||||
for (size_t i = 0; i < numTopics; ++i) |
|
||||
topics[i] = stack.pop(); |
|
||||
|
|
||||
_ext.log(beginIdx, numBytes, topics); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
default: // Invalid instruction - abort
|
|
||||
m_builder.CreateBr(m_abortBB); |
|
||||
it = _basicBlock.end() - 1; // finish block compilation
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
_gasMeter.commitCostBlock(); |
|
||||
|
|
||||
stack.finalize(m_builder, *_basicBlock.llvm()); // TODO: Use references
|
|
||||
|
|
||||
m_builder.SetInsertPoint(_basicBlock.llvm()->getFirstNonPHI()); // TODO: Move to LocalStack::finalize
|
|
||||
_runtimeManager.checkStackLimit(stack.minSize(), stack.maxSize(), stack.size()); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,59 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "BasicBlock.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
class Compiler |
|
||||
{ |
|
||||
public: |
|
||||
|
|
||||
struct Options |
|
||||
{ |
|
||||
/// Rewrite switch instructions to sequences of branches
|
|
||||
bool rewriteSwitchToBranches = true; |
|
||||
|
|
||||
/// Dump CFG as a .dot file for graphviz
|
|
||||
bool dumpCFG = false; |
|
||||
}; |
|
||||
|
|
||||
Compiler(Options const& _options); |
|
||||
|
|
||||
std::unique_ptr<llvm::Module> compile(code_iterator _begin, code_iterator _end, std::string const& _id); |
|
||||
|
|
||||
private: |
|
||||
|
|
||||
std::vector<BasicBlock> createBasicBlocks(code_iterator _begin, code_iterator _end, llvm::SwitchInst& _switchInst); |
|
||||
|
|
||||
void compileBasicBlock(BasicBlock& _basicBlock, class RuntimeManager& _runtimeManager, class Arith256& _arith, class Memory& _memory, class Ext& _ext, class GasMeter& _gasMeter, |
|
||||
class Stack& _globalStack); |
|
||||
|
|
||||
void resolveJumps(); |
|
||||
|
|
||||
/// Compiler options
|
|
||||
Options const& m_options; |
|
||||
|
|
||||
/// Helper class for generating IR
|
|
||||
llvm::IRBuilder<> m_builder; |
|
||||
|
|
||||
/// Stop basic block - terminates execution with STOP code (0)
|
|
||||
llvm::BasicBlock* m_stopBB = nullptr; |
|
||||
|
|
||||
/// Abort basic block - terminates execution with OOG-like state
|
|
||||
llvm::BasicBlock* m_abortBB = nullptr; |
|
||||
|
|
||||
/// Block with a jump table.
|
|
||||
llvm::BasicBlock* m_jumpTableBB = nullptr; |
|
||||
|
|
||||
/// Main program function
|
|
||||
llvm::Function* m_mainFunc = nullptr; // TODO: Remove
|
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,51 +0,0 @@ |
|||||
#include "CompilerHelper.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Module.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "RuntimeManager.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
CompilerHelper::CompilerHelper(llvm::IRBuilder<>& _builder) : |
|
||||
m_builder(_builder) |
|
||||
{} |
|
||||
|
|
||||
llvm::Module* CompilerHelper::getModule() |
|
||||
{ |
|
||||
assert(m_builder.GetInsertBlock()); |
|
||||
assert(m_builder.GetInsertBlock()->getParent()); // BB must be in a function
|
|
||||
return m_builder.GetInsertBlock()->getParent()->getParent(); |
|
||||
} |
|
||||
|
|
||||
llvm::Function* CompilerHelper::getMainFunction() |
|
||||
{ |
|
||||
// TODO: Rename or change semantics of getMainFunction() function
|
|
||||
assert(m_builder.GetInsertBlock()); |
|
||||
auto mainFunc = m_builder.GetInsertBlock()->getParent(); |
|
||||
assert(mainFunc); |
|
||||
if (mainFunc == &mainFunc->getParent()->getFunctionList().front()) // Main function is the first one in module
|
|
||||
return mainFunc; |
|
||||
return nullptr; |
|
||||
} |
|
||||
|
|
||||
llvm::CallInst* CompilerHelper::createCall(llvm::Function* _func, std::initializer_list<llvm::Value*> const& _args) |
|
||||
{ |
|
||||
return getBuilder().CreateCall(_func, {_args.begin(), _args.size()}); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
RuntimeHelper::RuntimeHelper(RuntimeManager& _runtimeManager): |
|
||||
CompilerHelper(_runtimeManager.getBuilder()), |
|
||||
m_runtimeManager(_runtimeManager) |
|
||||
{} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,64 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IRBuilder.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
class RuntimeManager; |
|
||||
|
|
||||
/// Base class for compiler helpers like Memory, GasMeter, etc.
|
|
||||
class CompilerHelper |
|
||||
{ |
|
||||
protected: |
|
||||
CompilerHelper(llvm::IRBuilder<>& _builder); |
|
||||
|
|
||||
CompilerHelper(const CompilerHelper&) = delete; |
|
||||
CompilerHelper& operator=(CompilerHelper) = delete; |
|
||||
|
|
||||
/// Reference to the IR module being compiled
|
|
||||
llvm::Module* getModule(); |
|
||||
|
|
||||
/// Reference to the main module function
|
|
||||
llvm::Function* getMainFunction(); |
|
||||
|
|
||||
/// Reference to parent compiler IR builder
|
|
||||
llvm::IRBuilder<>& m_builder; |
|
||||
llvm::IRBuilder<>& getBuilder() { return m_builder; } |
|
||||
|
|
||||
llvm::CallInst* createCall(llvm::Function* _func, std::initializer_list<llvm::Value*> const& _args); |
|
||||
|
|
||||
friend class RuntimeHelper; |
|
||||
}; |
|
||||
|
|
||||
/// Compiler helper that depends on runtime data
|
|
||||
class RuntimeHelper : public CompilerHelper |
|
||||
{ |
|
||||
protected: |
|
||||
RuntimeHelper(RuntimeManager& _runtimeManager); |
|
||||
|
|
||||
RuntimeManager& getRuntimeManager() { return m_runtimeManager; } |
|
||||
|
|
||||
private: |
|
||||
RuntimeManager& m_runtimeManager; |
|
||||
}; |
|
||||
|
|
||||
struct InsertPointGuard |
|
||||
{ |
|
||||
explicit InsertPointGuard(llvm::IRBuilderBase& _builder): m_builder(_builder), m_insertPoint(_builder.saveIP()) {} |
|
||||
~InsertPointGuard() { m_builder.restoreIP(m_insertPoint); } |
|
||||
|
|
||||
private: |
|
||||
llvm::IRBuilderBase& m_builder; |
|
||||
llvm::IRBuilderBase::InsertPoint m_insertPoint; |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,33 +0,0 @@ |
|||||
#include "Endianness.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include <llvm/Support/Host.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Type.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
llvm::Value* Endianness::bswapIfLE(llvm::IRBuilder<>& _builder, llvm::Value* _word) |
|
||||
{ |
|
||||
if (llvm::sys::IsLittleEndianHost) |
|
||||
{ |
|
||||
if (auto constant = llvm::dyn_cast<llvm::ConstantInt>(_word)) |
|
||||
return _builder.getInt(constant->getValue().byteSwap()); |
|
||||
|
|
||||
// OPT: Cache func declaration?
|
|
||||
auto bswapFunc = llvm::Intrinsic::getDeclaration(_builder.GetInsertBlock()->getParent()->getParent(), llvm::Intrinsic::bswap, Type::Word); |
|
||||
return _builder.CreateCall(bswapFunc, _word); |
|
||||
} |
|
||||
return _word; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,25 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IRBuilder.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
struct Endianness |
|
||||
{ |
|
||||
static llvm::Value* toBE(llvm::IRBuilder<>& _builder, llvm::Value* _word) { return bswapIfLE(_builder, _word); } |
|
||||
static llvm::Value* toNative(llvm::IRBuilder<>& _builder, llvm::Value* _word) { return bswapIfLE(_builder, _word); } |
|
||||
|
|
||||
private: |
|
||||
static llvm::Value* bswapIfLE(llvm::IRBuilder<>& _builder, llvm::Value* _word); |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,95 +0,0 @@ |
|||||
#include "ExecStats.h" |
|
||||
|
|
||||
#include <iostream> |
|
||||
#include <iomanip> |
|
||||
#include <cassert> |
|
||||
|
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
void ExecStats::stateChanged(ExecState _state) |
|
||||
{ |
|
||||
if (!CHECK(m_state != ExecState::Finished)) |
|
||||
return; |
|
||||
|
|
||||
auto now = clock::now(); |
|
||||
if (_state != ExecState::Started) |
|
||||
{ |
|
||||
assert(time[(int)m_state] == ExecStats::duration::zero()); |
|
||||
time[(int)m_state] = now - m_tp; |
|
||||
} |
|
||||
m_state = _state; |
|
||||
m_tp = now; |
|
||||
} |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
struct StatsAgg |
|
||||
{ |
|
||||
using unit = std::chrono::microseconds; |
|
||||
ExecStats::duration tot = ExecStats::duration::zero(); |
|
||||
ExecStats::duration min = ExecStats::duration::max(); |
|
||||
ExecStats::duration max = ExecStats::duration::zero(); |
|
||||
size_t count = 0; |
|
||||
|
|
||||
void update(ExecStats::duration _d) |
|
||||
{ |
|
||||
++count; |
|
||||
tot += _d; |
|
||||
min = _d < min ? _d : min; |
|
||||
max = _d > max ? _d : max; |
|
||||
} |
|
||||
|
|
||||
void output(char const* _name, std::ostream& _os) |
|
||||
{ |
|
||||
auto avg = tot / count; |
|
||||
_os << std::setfill(' ') |
|
||||
<< std::setw(12) << std::left << _name |
|
||||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(tot).count() |
|
||||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(avg).count() |
|
||||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(min).count() |
|
||||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(max).count() |
|
||||
<< std::endl; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
char const* getExecStateName(ExecState _state) |
|
||||
{ |
|
||||
switch (_state) |
|
||||
{ |
|
||||
case ExecState::Started: return "Start"; |
|
||||
case ExecState::CacheLoad: return "CacheLoad"; |
|
||||
case ExecState::CacheWrite: return "CacheWrite"; |
|
||||
case ExecState::Compilation: return "Compilation"; |
|
||||
case ExecState::Optimization: return "Optimization"; |
|
||||
case ExecState::CodeGen: return "CodeGen"; |
|
||||
case ExecState::Execution: return "Execution"; |
|
||||
case ExecState::Return: return "Return"; |
|
||||
case ExecState::Finished: return "Finish"; |
|
||||
} |
|
||||
return nullptr; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
StatsCollector::~StatsCollector() |
|
||||
{ |
|
||||
if (stats.empty()) |
|
||||
return; |
|
||||
|
|
||||
std::cout << " [us] total avg min max\n"; |
|
||||
for (int i = 0; i < (int)ExecState::Finished; ++i) |
|
||||
{ |
|
||||
StatsAgg agg; |
|
||||
for (auto&& s : stats) |
|
||||
agg.update(s->time[i]); |
|
||||
|
|
||||
agg.output(getExecStateName(ExecState(i)), std::cout); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,68 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <memory> |
|
||||
#include <vector> |
|
||||
#include <string> |
|
||||
#include <chrono> |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
enum class ExecState |
|
||||
{ |
|
||||
Started, |
|
||||
CacheLoad, |
|
||||
CacheWrite, |
|
||||
Compilation, |
|
||||
Optimization, |
|
||||
CodeGen, |
|
||||
Execution, |
|
||||
Return, |
|
||||
Finished |
|
||||
}; |
|
||||
|
|
||||
class JITListener |
|
||||
{ |
|
||||
public: |
|
||||
JITListener() = default; |
|
||||
JITListener(JITListener const&) = delete; |
|
||||
JITListener& operator=(JITListener) = delete; |
|
||||
virtual ~JITListener() {} |
|
||||
|
|
||||
virtual void executionStarted() {} |
|
||||
virtual void executionEnded() {} |
|
||||
|
|
||||
virtual void stateChanged(ExecState) {} |
|
||||
}; |
|
||||
|
|
||||
class ExecStats : public JITListener |
|
||||
{ |
|
||||
public: |
|
||||
using clock = std::chrono::high_resolution_clock; |
|
||||
using duration = clock::duration; |
|
||||
using time_point = clock::time_point; |
|
||||
|
|
||||
std::string id; |
|
||||
duration time[(int)ExecState::Finished] = {}; |
|
||||
|
|
||||
void stateChanged(ExecState _state) override; |
|
||||
|
|
||||
private: |
|
||||
ExecState m_state = {}; |
|
||||
time_point m_tp = {}; |
|
||||
|
|
||||
}; |
|
||||
|
|
||||
|
|
||||
class StatsCollector |
|
||||
{ |
|
||||
public: |
|
||||
std::vector<std::unique_ptr<ExecStats>> stats; |
|
||||
|
|
||||
~StatsCollector(); |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,210 +0,0 @@ |
|||||
#include "Ext.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "RuntimeManager.h" |
|
||||
#include "Memory.h" |
|
||||
#include "Type.h" |
|
||||
#include "Endianness.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
Ext::Ext(RuntimeManager& _runtimeManager, Memory& _memoryMan): |
|
||||
RuntimeHelper(_runtimeManager), |
|
||||
m_memoryMan(_memoryMan) |
|
||||
{ |
|
||||
m_funcs = decltype(m_funcs)(); |
|
||||
m_argAllocas = decltype(m_argAllocas)(); |
|
||||
m_size = m_builder.CreateAlloca(Type::Size, nullptr, "env.size"); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
using FuncDesc = std::tuple<char const*, llvm::FunctionType*>; |
|
||||
|
|
||||
llvm::FunctionType* getFunctionType(llvm::Type* _returnType, std::initializer_list<llvm::Type*> const& _argsTypes) |
|
||||
{ |
|
||||
return llvm::FunctionType::get(_returnType, llvm::ArrayRef<llvm::Type*>{_argsTypes.begin(), _argsTypes.size()}, false); |
|
||||
} |
|
||||
|
|
||||
std::array<FuncDesc, sizeOf<EnvFunc>::value> const& getEnvFuncDescs() |
|
||||
{ |
|
||||
static std::array<FuncDesc, sizeOf<EnvFunc>::value> descs{{ |
|
||||
FuncDesc{"env_sload", getFunctionType(Type::Void, {Type::EnvPtr, Type::WordPtr, Type::WordPtr})}, |
|
||||
FuncDesc{"env_sstore", getFunctionType(Type::Void, {Type::EnvPtr, Type::WordPtr, Type::WordPtr})}, |
|
||||
FuncDesc{"env_sha3", getFunctionType(Type::Void, {Type::BytePtr, Type::Size, Type::WordPtr})}, |
|
||||
FuncDesc{"env_balance", getFunctionType(Type::Void, {Type::EnvPtr, Type::WordPtr, Type::WordPtr})}, |
|
||||
FuncDesc{"env_create", getFunctionType(Type::Void, {Type::EnvPtr, Type::GasPtr, Type::WordPtr, Type::BytePtr, Type::Size, Type::WordPtr})}, |
|
||||
FuncDesc{"env_call", getFunctionType(Type::Bool, {Type::EnvPtr, Type::GasPtr, Type::Gas, Type::WordPtr, Type::WordPtr, Type::BytePtr, Type::Size, Type::BytePtr, Type::Size, Type::WordPtr})}, |
|
||||
FuncDesc{"env_log", getFunctionType(Type::Void, {Type::EnvPtr, Type::BytePtr, Type::Size, Type::WordPtr, Type::WordPtr, Type::WordPtr, Type::WordPtr})}, |
|
||||
FuncDesc{"env_blockhash", getFunctionType(Type::Void, {Type::EnvPtr, Type::WordPtr, Type::WordPtr})}, |
|
||||
FuncDesc{"env_extcode", getFunctionType(Type::BytePtr, {Type::EnvPtr, Type::WordPtr, Type::Size->getPointerTo()})}, |
|
||||
}}; |
|
||||
|
|
||||
return descs; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* createFunc(EnvFunc _id, llvm::Module* _module) |
|
||||
{ |
|
||||
auto&& desc = getEnvFuncDescs()[static_cast<size_t>(_id)]; |
|
||||
return llvm::Function::Create(std::get<1>(desc), llvm::Function::ExternalLinkage, std::get<0>(desc), _module); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::getArgAlloca() |
|
||||
{ |
|
||||
auto& a = m_argAllocas[m_argCounter]; |
|
||||
if (!a) |
|
||||
{ |
|
||||
InsertPointGuard g{getBuilder()}; |
|
||||
auto allocaIt = getMainFunction()->front().begin(); |
|
||||
std::advance(allocaIt, m_argCounter); // Skip already created allocas
|
|
||||
getBuilder().SetInsertPoint(allocaIt); |
|
||||
a = getBuilder().CreateAlloca(Type::Word, nullptr, {"a.", std::to_string(m_argCounter)}); |
|
||||
} |
|
||||
++m_argCounter; |
|
||||
return a; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::byPtr(llvm::Value* _value) |
|
||||
{ |
|
||||
auto a = getArgAlloca(); |
|
||||
getBuilder().CreateStore(_value, a); |
|
||||
return a; |
|
||||
} |
|
||||
|
|
||||
llvm::CallInst* Ext::createCall(EnvFunc _funcId, std::initializer_list<llvm::Value*> const& _args) |
|
||||
{ |
|
||||
auto& func = m_funcs[static_cast<size_t>(_funcId)]; |
|
||||
if (!func) |
|
||||
func = createFunc(_funcId, getModule()); |
|
||||
|
|
||||
m_argCounter = 0; |
|
||||
return getBuilder().CreateCall(func, {_args.begin(), _args.size()}); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::sload(llvm::Value* _index) |
|
||||
{ |
|
||||
auto ret = getArgAlloca(); |
|
||||
createCall(EnvFunc::sload, {getRuntimeManager().getEnvPtr(), byPtr(_index), ret}); // Uses native endianness
|
|
||||
return m_builder.CreateLoad(ret); |
|
||||
} |
|
||||
|
|
||||
void Ext::sstore(llvm::Value* _index, llvm::Value* _value) |
|
||||
{ |
|
||||
createCall(EnvFunc::sstore, {getRuntimeManager().getEnvPtr(), byPtr(_index), byPtr(_value)}); // Uses native endianness
|
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::calldataload(llvm::Value* _idx) |
|
||||
{ |
|
||||
auto ret = getArgAlloca(); |
|
||||
auto result = m_builder.CreateBitCast(ret, Type::BytePtr); |
|
||||
|
|
||||
auto callDataSize = getRuntimeManager().getCallDataSize(); |
|
||||
auto callDataSize64 = m_builder.CreateTrunc(callDataSize, Type::Size); |
|
||||
auto idxValid = m_builder.CreateICmpULT(_idx, callDataSize); |
|
||||
auto idx = m_builder.CreateTrunc(m_builder.CreateSelect(idxValid, _idx, callDataSize), Type::Size, "idx"); |
|
||||
|
|
||||
auto end = m_builder.CreateNUWAdd(idx, m_builder.getInt64(32)); |
|
||||
end = m_builder.CreateSelect(m_builder.CreateICmpULE(end, callDataSize64), end, callDataSize64); |
|
||||
auto copySize = m_builder.CreateNUWSub(end, idx); |
|
||||
auto padSize = m_builder.CreateNUWSub(m_builder.getInt64(32), copySize); |
|
||||
auto dataBegin = m_builder.CreateGEP(Type::Byte, getRuntimeManager().getCallData(), idx); |
|
||||
m_builder.CreateMemCpy(result, dataBegin, copySize, 1); |
|
||||
auto pad = m_builder.CreateGEP(Type::Byte, result, copySize); |
|
||||
m_builder.CreateMemSet(pad, m_builder.getInt8(0), padSize, 1); |
|
||||
|
|
||||
m_argCounter = 0; // Release args allocas. TODO: This is a bad design
|
|
||||
return Endianness::toNative(m_builder, m_builder.CreateLoad(ret)); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::balance(llvm::Value* _address) |
|
||||
{ |
|
||||
auto address = Endianness::toBE(m_builder, _address); |
|
||||
auto ret = getArgAlloca(); |
|
||||
createCall(EnvFunc::balance, {getRuntimeManager().getEnvPtr(), byPtr(address), ret}); |
|
||||
return m_builder.CreateLoad(ret); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::blockHash(llvm::Value* _number) |
|
||||
{ |
|
||||
auto hash = getArgAlloca(); |
|
||||
createCall(EnvFunc::blockhash, {getRuntimeManager().getEnvPtr(), byPtr(_number), hash}); |
|
||||
hash = m_builder.CreateLoad(hash); |
|
||||
return Endianness::toNative(getBuilder(), hash); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::create(llvm::Value* _endowment, llvm::Value* _initOff, llvm::Value* _initSize) |
|
||||
{ |
|
||||
auto ret = getArgAlloca(); |
|
||||
auto begin = m_memoryMan.getBytePtr(_initOff); |
|
||||
auto size = m_builder.CreateTrunc(_initSize, Type::Size, "size"); |
|
||||
createCall(EnvFunc::create, {getRuntimeManager().getEnvPtr(), getRuntimeManager().getGasPtr(), byPtr(_endowment), begin, size, ret}); |
|
||||
llvm::Value* address = m_builder.CreateLoad(ret); |
|
||||
address = Endianness::toNative(m_builder, address); |
|
||||
return address; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::call(llvm::Value* _callGas, llvm::Value* _receiveAddress, llvm::Value* _value, llvm::Value* _inOff, llvm::Value* _inSize, llvm::Value* _outOff, llvm::Value* _outSize, llvm::Value* _codeAddress) |
|
||||
{ |
|
||||
auto receiveAddress = Endianness::toBE(m_builder, _receiveAddress); |
|
||||
auto inBeg = m_memoryMan.getBytePtr(_inOff); |
|
||||
auto inSize = m_builder.CreateTrunc(_inSize, Type::Size, "in.size"); |
|
||||
auto outBeg = m_memoryMan.getBytePtr(_outOff); |
|
||||
auto outSize = m_builder.CreateTrunc(_outSize, Type::Size, "out.size"); |
|
||||
auto codeAddress = Endianness::toBE(m_builder, _codeAddress); |
|
||||
auto callGas = m_builder.CreateSelect( |
|
||||
m_builder.CreateICmpULE(_callGas, m_builder.CreateZExt(Constant::gasMax, Type::Word)), |
|
||||
m_builder.CreateTrunc(_callGas, Type::Gas), |
|
||||
Constant::gasMax); |
|
||||
auto ret = createCall(EnvFunc::call, {getRuntimeManager().getEnvPtr(), getRuntimeManager().getGasPtr(), callGas, byPtr(receiveAddress), byPtr(_value), inBeg, inSize, outBeg, outSize, byPtr(codeAddress)}); |
|
||||
return m_builder.CreateZExt(ret, Type::Word, "ret"); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Ext::sha3(llvm::Value* _inOff, llvm::Value* _inSize) |
|
||||
{ |
|
||||
auto begin = m_memoryMan.getBytePtr(_inOff); |
|
||||
auto size = m_builder.CreateTrunc(_inSize, Type::Size, "size"); |
|
||||
auto ret = getArgAlloca(); |
|
||||
createCall(EnvFunc::sha3, {begin, size, ret}); |
|
||||
llvm::Value* hash = m_builder.CreateLoad(ret); |
|
||||
hash = Endianness::toNative(m_builder, hash); |
|
||||
return hash; |
|
||||
} |
|
||||
|
|
||||
MemoryRef Ext::extcode(llvm::Value* _addr) |
|
||||
{ |
|
||||
auto addr = Endianness::toBE(m_builder, _addr); |
|
||||
auto code = createCall(EnvFunc::extcode, {getRuntimeManager().getEnvPtr(), byPtr(addr), m_size}); |
|
||||
auto codeSize = m_builder.CreateLoad(m_size); |
|
||||
auto codeSize256 = m_builder.CreateZExt(codeSize, Type::Word); |
|
||||
return {code, codeSize256}; |
|
||||
} |
|
||||
|
|
||||
void Ext::log(llvm::Value* _memIdx, llvm::Value* _numBytes, std::array<llvm::Value*,4> const& _topics) |
|
||||
{ |
|
||||
auto begin = m_memoryMan.getBytePtr(_memIdx); |
|
||||
auto size = m_builder.CreateTrunc(_numBytes, Type::Size, "size"); |
|
||||
llvm::Value* args[] = {getRuntimeManager().getEnvPtr(), begin, size, getArgAlloca(), getArgAlloca(), getArgAlloca(), getArgAlloca()}; |
|
||||
|
|
||||
auto topicArgPtr = &args[3]; |
|
||||
for (auto&& topic : _topics) |
|
||||
{ |
|
||||
if (topic) |
|
||||
m_builder.CreateStore(Endianness::toBE(m_builder, topic), *topicArgPtr); |
|
||||
else |
|
||||
*topicArgPtr = llvm::ConstantPointerNull::get(Type::WordPtr); |
|
||||
++topicArgPtr; |
|
||||
} |
|
||||
|
|
||||
createCall(EnvFunc::log, {args[0], args[1], args[2], args[3], args[4], args[5], args[6]}); // TODO: use std::initializer_list<>
|
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,79 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <array> |
|
||||
|
|
||||
#include "CompilerHelper.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
class Memory; |
|
||||
|
|
||||
struct MemoryRef |
|
||||
{ |
|
||||
llvm::Value* ptr; |
|
||||
llvm::Value* size; |
|
||||
}; |
|
||||
|
|
||||
template<typename _EnumT> |
|
||||
struct sizeOf |
|
||||
{ |
|
||||
static const size_t value = static_cast<size_t>(_EnumT::_size); |
|
||||
}; |
|
||||
|
|
||||
enum class EnvFunc |
|
||||
{ |
|
||||
sload, |
|
||||
sstore, |
|
||||
sha3, |
|
||||
balance, |
|
||||
create, |
|
||||
call, |
|
||||
log, |
|
||||
blockhash, |
|
||||
extcode, |
|
||||
|
|
||||
_size |
|
||||
}; |
|
||||
|
|
||||
class Ext : public RuntimeHelper |
|
||||
{ |
|
||||
public: |
|
||||
Ext(RuntimeManager& _runtimeManager, Memory& _memoryMan); |
|
||||
|
|
||||
llvm::Value* sload(llvm::Value* _index); |
|
||||
void sstore(llvm::Value* _index, llvm::Value* _value); |
|
||||
|
|
||||
llvm::Value* balance(llvm::Value* _address); |
|
||||
llvm::Value* calldataload(llvm::Value* _index); |
|
||||
llvm::Value* create(llvm::Value* _endowment, llvm::Value* _initOff, llvm::Value* _initSize); |
|
||||
llvm::Value* call(llvm::Value* _callGas, llvm::Value* _receiveAddress, llvm::Value* _value, llvm::Value* _inOff, llvm::Value* _inSize, llvm::Value* _outOff, llvm::Value* _outSize, llvm::Value* _codeAddress); |
|
||||
llvm::Value* blockHash(llvm::Value* _number); |
|
||||
|
|
||||
llvm::Value* sha3(llvm::Value* _inOff, llvm::Value* _inSize); |
|
||||
MemoryRef extcode(llvm::Value* _addr); |
|
||||
|
|
||||
void log(llvm::Value* _memIdx, llvm::Value* _numBytes, std::array<llvm::Value*,4> const& _topics); |
|
||||
|
|
||||
private: |
|
||||
Memory& m_memoryMan; |
|
||||
|
|
||||
llvm::Value* m_size; |
|
||||
|
|
||||
std::array<llvm::Function*, sizeOf<EnvFunc>::value> m_funcs; |
|
||||
std::array<llvm::Value*, 8> m_argAllocas; |
|
||||
size_t m_argCounter = 0; |
|
||||
|
|
||||
llvm::CallInst* createCall(EnvFunc _funcId, std::initializer_list<llvm::Value*> const& _args); |
|
||||
llvm::Value* getArgAlloca(); |
|
||||
llvm::Value* byPtr(llvm::Value* _value); |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,299 +0,0 @@ |
|||||
#include "GasMeter.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Ext.h" |
|
||||
#include "RuntimeManager.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
namespace // Helper functions
|
|
||||
{ |
|
||||
|
|
||||
int64_t const c_stepGas[] = {0, 2, 3, 5, 8, 10, 20}; |
|
||||
int64_t const c_expByteGas = 10; |
|
||||
int64_t const c_sha3Gas = 30; |
|
||||
int64_t const c_sha3WordGas = 6; |
|
||||
int64_t const c_sloadGas = 50; |
|
||||
int64_t const c_sstoreSetGas = 20000; |
|
||||
int64_t const c_sstoreResetGas = 5000; |
|
||||
int64_t const c_sstoreClearGas = 5000; |
|
||||
int64_t const c_jumpdestGas = 1; |
|
||||
int64_t const c_logGas = 375; |
|
||||
int64_t const c_logTopicGas = 375; |
|
||||
int64_t const c_logDataGas = 8; |
|
||||
int64_t const c_callGas = 40; |
|
||||
int64_t const c_createGas = 32000; |
|
||||
int64_t const c_memoryGas = 3; |
|
||||
int64_t const c_copyGas = 3; |
|
||||
|
|
||||
int64_t getStepCost(Instruction inst) |
|
||||
{ |
|
||||
switch (inst) |
|
||||
{ |
|
||||
// Tier 0
|
|
||||
case Instruction::STOP: |
|
||||
case Instruction::RETURN: |
|
||||
case Instruction::SUICIDE: |
|
||||
case Instruction::SSTORE: // Handle cost of SSTORE separately in GasMeter::countSStore()
|
|
||||
return c_stepGas[0]; |
|
||||
|
|
||||
// Tier 1
|
|
||||
case Instruction::ADDRESS: |
|
||||
case Instruction::ORIGIN: |
|
||||
case Instruction::CALLER: |
|
||||
case Instruction::CALLVALUE: |
|
||||
case Instruction::CALLDATASIZE: |
|
||||
case Instruction::CODESIZE: |
|
||||
case Instruction::GASPRICE: |
|
||||
case Instruction::COINBASE: |
|
||||
case Instruction::TIMESTAMP: |
|
||||
case Instruction::NUMBER: |
|
||||
case Instruction::DIFFICULTY: |
|
||||
case Instruction::GASLIMIT: |
|
||||
case Instruction::POP: |
|
||||
case Instruction::PC: |
|
||||
case Instruction::MSIZE: |
|
||||
case Instruction::GAS: |
|
||||
return c_stepGas[1]; |
|
||||
|
|
||||
// Tier 2
|
|
||||
case Instruction::ADD: |
|
||||
case Instruction::SUB: |
|
||||
case Instruction::LT: |
|
||||
case Instruction::GT: |
|
||||
case Instruction::SLT: |
|
||||
case Instruction::SGT: |
|
||||
case Instruction::EQ: |
|
||||
case Instruction::ISZERO: |
|
||||
case Instruction::AND: |
|
||||
case Instruction::OR: |
|
||||
case Instruction::XOR: |
|
||||
case Instruction::NOT: |
|
||||
case Instruction::BYTE: |
|
||||
case Instruction::CALLDATALOAD: |
|
||||
case Instruction::CALLDATACOPY: |
|
||||
case Instruction::CODECOPY: |
|
||||
case Instruction::MLOAD: |
|
||||
case Instruction::MSTORE: |
|
||||
case Instruction::MSTORE8: |
|
||||
case Instruction::ANY_PUSH: |
|
||||
case Instruction::ANY_DUP: |
|
||||
case Instruction::ANY_SWAP: |
|
||||
return c_stepGas[2]; |
|
||||
|
|
||||
// Tier 3
|
|
||||
case Instruction::MUL: |
|
||||
case Instruction::DIV: |
|
||||
case Instruction::SDIV: |
|
||||
case Instruction::MOD: |
|
||||
case Instruction::SMOD: |
|
||||
case Instruction::SIGNEXTEND: |
|
||||
return c_stepGas[3]; |
|
||||
|
|
||||
// Tier 4
|
|
||||
case Instruction::ADDMOD: |
|
||||
case Instruction::MULMOD: |
|
||||
case Instruction::JUMP: |
|
||||
return c_stepGas[4]; |
|
||||
|
|
||||
// Tier 5
|
|
||||
case Instruction::EXP: |
|
||||
case Instruction::JUMPI: |
|
||||
return c_stepGas[5]; |
|
||||
|
|
||||
// Tier 6
|
|
||||
case Instruction::BALANCE: |
|
||||
case Instruction::EXTCODESIZE: |
|
||||
case Instruction::EXTCODECOPY: |
|
||||
case Instruction::BLOCKHASH: |
|
||||
return c_stepGas[6]; |
|
||||
|
|
||||
case Instruction::SHA3: |
|
||||
return c_sha3Gas; |
|
||||
|
|
||||
case Instruction::SLOAD: |
|
||||
return c_sloadGas; |
|
||||
|
|
||||
case Instruction::JUMPDEST: |
|
||||
return c_jumpdestGas; |
|
||||
|
|
||||
case Instruction::LOG0: |
|
||||
case Instruction::LOG1: |
|
||||
case Instruction::LOG2: |
|
||||
case Instruction::LOG3: |
|
||||
case Instruction::LOG4: |
|
||||
{ |
|
||||
auto numTopics = static_cast<int64_t>(inst) - static_cast<int64_t>(Instruction::LOG0); |
|
||||
return c_logGas + numTopics * c_logTopicGas; |
|
||||
} |
|
||||
|
|
||||
case Instruction::CALL: |
|
||||
case Instruction::CALLCODE: |
|
||||
return c_callGas; |
|
||||
|
|
||||
case Instruction::CREATE: |
|
||||
return c_createGas; |
|
||||
} |
|
||||
|
|
||||
return 0; // TODO: Add UNREACHABLE macro
|
|
||||
} |
|
||||
|
|
||||
} |
|
||||
|
|
||||
GasMeter::GasMeter(llvm::IRBuilder<>& _builder, RuntimeManager& _runtimeManager) : |
|
||||
CompilerHelper(_builder), |
|
||||
m_runtimeManager(_runtimeManager) |
|
||||
{ |
|
||||
llvm::Type* gasCheckArgs[] = {Type::Gas->getPointerTo(), Type::Gas, Type::BytePtr}; |
|
||||
m_gasCheckFunc = llvm::Function::Create(llvm::FunctionType::get(Type::Void, gasCheckArgs, false), llvm::Function::PrivateLinkage, "gas.check", getModule()); |
|
||||
m_gasCheckFunc->setDoesNotThrow(); |
|
||||
m_gasCheckFunc->setDoesNotCapture(1); |
|
||||
|
|
||||
auto checkBB = llvm::BasicBlock::Create(_builder.getContext(), "Check", m_gasCheckFunc); |
|
||||
auto updateBB = llvm::BasicBlock::Create(_builder.getContext(), "Update", m_gasCheckFunc); |
|
||||
auto outOfGasBB = llvm::BasicBlock::Create(_builder.getContext(), "OutOfGas", m_gasCheckFunc); |
|
||||
|
|
||||
auto gasPtr = &m_gasCheckFunc->getArgumentList().front(); |
|
||||
gasPtr->setName("gasPtr"); |
|
||||
auto cost = gasPtr->getNextNode(); |
|
||||
cost->setName("cost"); |
|
||||
auto jmpBuf = cost->getNextNode(); |
|
||||
jmpBuf->setName("jmpBuf"); |
|
||||
|
|
||||
InsertPointGuard guard(m_builder); |
|
||||
m_builder.SetInsertPoint(checkBB); |
|
||||
auto gas = m_builder.CreateLoad(gasPtr, "gas"); |
|
||||
auto gasUpdated = m_builder.CreateNSWSub(gas, cost, "gasUpdated"); |
|
||||
auto gasOk = m_builder.CreateICmpSGE(gasUpdated, m_builder.getInt64(0), "gasOk"); // gas >= 0, with gas == 0 we can still do 0 cost instructions
|
|
||||
m_builder.CreateCondBr(gasOk, updateBB, outOfGasBB, Type::expectTrue); |
|
||||
|
|
||||
m_builder.SetInsertPoint(updateBB); |
|
||||
m_builder.CreateStore(gasUpdated, gasPtr); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
|
|
||||
m_builder.SetInsertPoint(outOfGasBB); |
|
||||
m_runtimeManager.abort(jmpBuf); |
|
||||
m_builder.CreateUnreachable(); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::count(Instruction _inst) |
|
||||
{ |
|
||||
if (!m_checkCall) |
|
||||
{ |
|
||||
// Create gas check call with mocked block cost at begining of current cost-block
|
|
||||
m_checkCall = createCall(m_gasCheckFunc, {m_runtimeManager.getGasPtr(), llvm::UndefValue::get(Type::Gas), m_runtimeManager.getJmpBuf()}); |
|
||||
} |
|
||||
|
|
||||
m_blockCost += getStepCost(_inst); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::count(llvm::Value* _cost, llvm::Value* _jmpBuf, llvm::Value* _gasPtr) |
|
||||
{ |
|
||||
if (_cost->getType() == Type::Word) |
|
||||
{ |
|
||||
auto gasMax256 = m_builder.CreateZExt(Constant::gasMax, Type::Word); |
|
||||
auto tooHigh = m_builder.CreateICmpUGT(_cost, gasMax256, "costTooHigh"); |
|
||||
auto cost64 = m_builder.CreateTrunc(_cost, Type::Gas); |
|
||||
_cost = m_builder.CreateSelect(tooHigh, Constant::gasMax, cost64, "cost"); |
|
||||
} |
|
||||
|
|
||||
assert(_cost->getType() == Type::Gas); |
|
||||
createCall(m_gasCheckFunc, {_gasPtr ? _gasPtr : m_runtimeManager.getGasPtr(), _cost, _jmpBuf ? _jmpBuf : m_runtimeManager.getJmpBuf()}); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::countExp(llvm::Value* _exponent) |
|
||||
{ |
|
||||
// Additional cost is 1 per significant byte of exponent
|
|
||||
// lz - leading zeros
|
|
||||
// cost = ((256 - lz) + 7) / 8
|
|
||||
|
|
||||
// OPT: Can gas update be done in exp algorithm?
|
|
||||
auto ctlz = llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::ctlz, Type::Word); |
|
||||
auto lz256 = m_builder.CreateCall(ctlz, {_exponent, m_builder.getInt1(false)}); |
|
||||
auto lz = m_builder.CreateTrunc(lz256, Type::Gas, "lz"); |
|
||||
auto sigBits = m_builder.CreateSub(m_builder.getInt64(256), lz, "sigBits"); |
|
||||
auto sigBytes = m_builder.CreateUDiv(m_builder.CreateAdd(sigBits, m_builder.getInt64(7)), m_builder.getInt64(8)); |
|
||||
count(m_builder.CreateNUWMul(sigBytes, m_builder.getInt64(c_expByteGas))); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::countSStore(Ext& _ext, llvm::Value* _index, llvm::Value* _newValue) |
|
||||
{ |
|
||||
auto oldValue = _ext.sload(_index); |
|
||||
auto oldValueIsZero = m_builder.CreateICmpEQ(oldValue, Constant::get(0), "oldValueIsZero"); |
|
||||
auto newValueIsntZero = m_builder.CreateICmpNE(_newValue, Constant::get(0), "newValueIsntZero"); |
|
||||
auto isInsert = m_builder.CreateAnd(oldValueIsZero, newValueIsntZero, "isInsert"); |
|
||||
static_assert(c_sstoreResetGas == c_sstoreClearGas, "Update SSTORE gas cost"); |
|
||||
auto cost = m_builder.CreateSelect(isInsert, m_builder.getInt64(c_sstoreSetGas), m_builder.getInt64(c_sstoreResetGas), "cost"); |
|
||||
count(cost); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::countLogData(llvm::Value* _dataLength) |
|
||||
{ |
|
||||
assert(m_checkCall); |
|
||||
assert(m_blockCost > 0); // LOGn instruction is already counted
|
|
||||
static_assert(c_logDataGas != 1, "Log data gas cost has changed. Update GasMeter."); |
|
||||
count(m_builder.CreateNUWMul(_dataLength, Constant::get(c_logDataGas))); // TODO: Use i64
|
|
||||
} |
|
||||
|
|
||||
void GasMeter::countSha3Data(llvm::Value* _dataLength) |
|
||||
{ |
|
||||
assert(m_checkCall); |
|
||||
assert(m_blockCost > 0); // SHA3 instruction is already counted
|
|
||||
|
|
||||
// TODO: This round ups to 32 happens in many places
|
|
||||
static_assert(c_sha3WordGas != 1, "SHA3 data cost has changed. Update GasMeter"); |
|
||||
auto dataLength64 = getBuilder().CreateTrunc(_dataLength, Type::Gas); |
|
||||
auto words64 = m_builder.CreateUDiv(m_builder.CreateNUWAdd(dataLength64, getBuilder().getInt64(31)), getBuilder().getInt64(32)); |
|
||||
auto cost64 = m_builder.CreateNUWMul(getBuilder().getInt64(c_sha3WordGas), words64); |
|
||||
count(cost64); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::giveBack(llvm::Value* _gas) |
|
||||
{ |
|
||||
assert(_gas->getType() == Type::Gas); |
|
||||
m_runtimeManager.setGas(m_builder.CreateAdd(m_runtimeManager.getGas(), _gas)); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::commitCostBlock() |
|
||||
{ |
|
||||
// If any uncommited block
|
|
||||
if (m_checkCall) |
|
||||
{ |
|
||||
if (m_blockCost == 0) // Do not check 0
|
|
||||
{ |
|
||||
m_checkCall->eraseFromParent(); // Remove the gas check call
|
|
||||
m_checkCall = nullptr; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
m_checkCall->setArgOperand(1, m_builder.getInt64(m_blockCost)); // Update block cost in gas check call
|
|
||||
m_checkCall = nullptr; // End cost-block
|
|
||||
m_blockCost = 0; |
|
||||
} |
|
||||
assert(m_blockCost == 0); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::countMemory(llvm::Value* _additionalMemoryInWords, llvm::Value* _jmpBuf, llvm::Value* _gasPtr) |
|
||||
{ |
|
||||
static_assert(c_memoryGas != 1, "Memory gas cost has changed. Update GasMeter."); |
|
||||
count(_additionalMemoryInWords, _jmpBuf, _gasPtr); |
|
||||
} |
|
||||
|
|
||||
void GasMeter::countCopy(llvm::Value* _copyWords) |
|
||||
{ |
|
||||
static_assert(c_copyGas != 1, "Copy gas cost has changed. Update GasMeter."); |
|
||||
count(m_builder.CreateNUWMul(_copyWords, m_builder.getInt64(c_copyGas))); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,64 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "CompilerHelper.h" |
|
||||
#include "Instruction.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
class RuntimeManager; |
|
||||
using namespace evmjit; |
|
||||
|
|
||||
class GasMeter : public CompilerHelper // TODO: Use RuntimeHelper
|
|
||||
{ |
|
||||
public: |
|
||||
GasMeter(llvm::IRBuilder<>& _builder, RuntimeManager& _runtimeManager); |
|
||||
|
|
||||
/// Count step cost of instruction
|
|
||||
void count(Instruction _inst); |
|
||||
|
|
||||
/// Count additional cost
|
|
||||
void count(llvm::Value* _cost, llvm::Value* _jmpBuf = nullptr, llvm::Value* _gasPtr = nullptr); |
|
||||
|
|
||||
/// Calculate & count gas cost for SSTORE instruction
|
|
||||
void countSStore(class Ext& _ext, llvm::Value* _index, llvm::Value* _newValue); |
|
||||
|
|
||||
/// Calculate & count additional gas cost for EXP instruction
|
|
||||
void countExp(llvm::Value* _exponent); |
|
||||
|
|
||||
/// Count gas cost of LOG data
|
|
||||
void countLogData(llvm::Value* _dataLength); |
|
||||
|
|
||||
/// Count gas cost of SHA3 data
|
|
||||
void countSha3Data(llvm::Value* _dataLength); |
|
||||
|
|
||||
/// Finalize cost-block by checking gas needed for the block before the block
|
|
||||
void commitCostBlock(); |
|
||||
|
|
||||
/// Give back an amount of gas not used by a call
|
|
||||
void giveBack(llvm::Value* _gas); |
|
||||
|
|
||||
/// Generate code that checks the cost of additional memory used by program
|
|
||||
void countMemory(llvm::Value* _additionalMemoryInWords, llvm::Value* _jmpBuf, llvm::Value* _gasPtr); |
|
||||
|
|
||||
/// Count addional gas cost for memory copy
|
|
||||
void countCopy(llvm::Value* _copyWords); |
|
||||
|
|
||||
private: |
|
||||
/// Cumulative gas cost of a block of instructions
|
|
||||
/// @TODO Handle overflow
|
|
||||
int64_t m_blockCost = 0; |
|
||||
|
|
||||
llvm::CallInst* m_checkCall = nullptr; |
|
||||
llvm::Function* m_gasCheckFunc = nullptr; |
|
||||
|
|
||||
RuntimeManager& m_runtimeManager; |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,39 +0,0 @@ |
|||||
#include "Instruction.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/ADT/APInt.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
llvm::APInt readPushData(code_iterator& _curr, code_iterator _end) |
|
||||
{ |
|
||||
auto pushInst = *_curr; |
|
||||
assert(Instruction(pushInst) >= Instruction::PUSH1 && Instruction(pushInst) <= Instruction::PUSH32); |
|
||||
auto numBytes = pushInst - static_cast<size_t>(Instruction::PUSH1) + 1; |
|
||||
llvm::APInt value(256, 0); |
|
||||
++_curr; // Point the data
|
|
||||
for (decltype(numBytes) i = 0; i < numBytes; ++i) |
|
||||
{ |
|
||||
byte b = (_curr != _end) ? *_curr++ : 0; |
|
||||
value <<= 8; |
|
||||
value |= b; |
|
||||
} |
|
||||
--_curr; // Point the last real byte read
|
|
||||
return value; |
|
||||
} |
|
||||
|
|
||||
void skipPushData(code_iterator& _curr, code_iterator _end) |
|
||||
{ |
|
||||
auto pushInst = *_curr; |
|
||||
assert(Instruction(pushInst) >= Instruction::PUSH1 && Instruction(pushInst) <= Instruction::PUSH32); |
|
||||
auto numBytes = pushInst - static_cast<size_t>(Instruction::PUSH1) + 1; |
|
||||
--_end; |
|
||||
for (decltype(numBytes) i = 0; i < numBytes && _curr < _end; ++i, ++_curr) {} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,236 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "Common.h" |
|
||||
|
|
||||
namespace llvm |
|
||||
{ |
|
||||
class APInt; |
|
||||
} |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
/// Virtual machine bytecode instruction.
|
|
||||
enum class Instruction: uint8_t |
|
||||
{ |
|
||||
STOP = 0x00, ///< halts execution
|
|
||||
ADD, ///< addition operation
|
|
||||
MUL, ///< mulitplication operation
|
|
||||
SUB, ///< subtraction operation
|
|
||||
DIV, ///< integer division operation
|
|
||||
SDIV, ///< signed integer division operation
|
|
||||
MOD, ///< modulo remainder operation
|
|
||||
SMOD, ///< signed modulo remainder operation
|
|
||||
ADDMOD, ///< unsigned modular addition
|
|
||||
MULMOD, ///< unsigned modular multiplication
|
|
||||
EXP, ///< exponential operation
|
|
||||
SIGNEXTEND, ///< extend length of signed integer
|
|
||||
|
|
||||
LT = 0x10, ///< less-than comparision
|
|
||||
GT, ///< greater-than comparision
|
|
||||
SLT, ///< signed less-than comparision
|
|
||||
SGT, ///< signed greater-than comparision
|
|
||||
EQ, ///< equality comparision
|
|
||||
ISZERO, ///< simple not operator
|
|
||||
AND, ///< bitwise AND operation
|
|
||||
OR, ///< bitwise OR operation
|
|
||||
XOR, ///< bitwise XOR operation
|
|
||||
NOT, ///< bitwise NOT opertation
|
|
||||
BYTE, ///< retrieve single byte from word
|
|
||||
|
|
||||
SHA3 = 0x20, ///< compute SHA3-256 hash
|
|
||||
|
|
||||
ADDRESS = 0x30, ///< get address of currently executing account
|
|
||||
BALANCE, ///< get balance of the given account
|
|
||||
ORIGIN, ///< get execution origination address
|
|
||||
CALLER, ///< get caller address
|
|
||||
CALLVALUE, ///< get deposited value by the instruction/transaction responsible for this execution
|
|
||||
CALLDATALOAD, ///< get input data of current environment
|
|
||||
CALLDATASIZE, ///< get size of input data in current environment
|
|
||||
CALLDATACOPY, ///< copy input data in current environment to memory
|
|
||||
CODESIZE, ///< get size of code running in current environment
|
|
||||
CODECOPY, ///< copy code running in current environment to memory
|
|
||||
GASPRICE, ///< get price of gas in current environment
|
|
||||
EXTCODESIZE, ///< get external code size (from another contract)
|
|
||||
EXTCODECOPY, ///< copy external code (from another contract)
|
|
||||
|
|
||||
BLOCKHASH = 0x40, ///< get hash of most recent complete block
|
|
||||
COINBASE, ///< get the block's coinbase address
|
|
||||
TIMESTAMP, ///< get the block's timestamp
|
|
||||
NUMBER, ///< get the block's number
|
|
||||
DIFFICULTY, ///< get the block's difficulty
|
|
||||
GASLIMIT, ///< get the block's gas limit
|
|
||||
|
|
||||
POP = 0x50, ///< remove item from stack
|
|
||||
MLOAD, ///< load word from memory
|
|
||||
MSTORE, ///< save word to memory
|
|
||||
MSTORE8, ///< save byte to memory
|
|
||||
SLOAD, ///< load word from storage
|
|
||||
SSTORE, ///< save word to storage
|
|
||||
JUMP, ///< alter the program counter
|
|
||||
JUMPI, ///< conditionally alter the program counter
|
|
||||
PC, ///< get the program counter
|
|
||||
MSIZE, ///< get the size of active memory
|
|
||||
GAS, ///< get the amount of available gas
|
|
||||
JUMPDEST, ///< set a potential jump destination
|
|
||||
|
|
||||
PUSH1 = 0x60, ///< place 1 byte item on stack
|
|
||||
PUSH2, ///< place 2 byte item on stack
|
|
||||
PUSH3, ///< place 3 byte item on stack
|
|
||||
PUSH4, ///< place 4 byte item on stack
|
|
||||
PUSH5, ///< place 5 byte item on stack
|
|
||||
PUSH6, ///< place 6 byte item on stack
|
|
||||
PUSH7, ///< place 7 byte item on stack
|
|
||||
PUSH8, ///< place 8 byte item on stack
|
|
||||
PUSH9, ///< place 9 byte item on stack
|
|
||||
PUSH10, ///< place 10 byte item on stack
|
|
||||
PUSH11, ///< place 11 byte item on stack
|
|
||||
PUSH12, ///< place 12 byte item on stack
|
|
||||
PUSH13, ///< place 13 byte item on stack
|
|
||||
PUSH14, ///< place 14 byte item on stack
|
|
||||
PUSH15, ///< place 15 byte item on stack
|
|
||||
PUSH16, ///< place 16 byte item on stack
|
|
||||
PUSH17, ///< place 17 byte item on stack
|
|
||||
PUSH18, ///< place 18 byte item on stack
|
|
||||
PUSH19, ///< place 19 byte item on stack
|
|
||||
PUSH20, ///< place 20 byte item on stack
|
|
||||
PUSH21, ///< place 21 byte item on stack
|
|
||||
PUSH22, ///< place 22 byte item on stack
|
|
||||
PUSH23, ///< place 23 byte item on stack
|
|
||||
PUSH24, ///< place 24 byte item on stack
|
|
||||
PUSH25, ///< place 25 byte item on stack
|
|
||||
PUSH26, ///< place 26 byte item on stack
|
|
||||
PUSH27, ///< place 27 byte item on stack
|
|
||||
PUSH28, ///< place 28 byte item on stack
|
|
||||
PUSH29, ///< place 29 byte item on stack
|
|
||||
PUSH30, ///< place 30 byte item on stack
|
|
||||
PUSH31, ///< place 31 byte item on stack
|
|
||||
PUSH32, ///< place 32 byte item on stack
|
|
||||
|
|
||||
DUP1 = 0x80, ///< copies the highest item in the stack to the top of the stack
|
|
||||
DUP2, ///< copies the second highest item in the stack to the top of the stack
|
|
||||
DUP3, ///< copies the third highest item in the stack to the top of the stack
|
|
||||
DUP4, ///< copies the 4th highest item in the stack to the top of the stack
|
|
||||
DUP5, ///< copies the 5th highest item in the stack to the top of the stack
|
|
||||
DUP6, ///< copies the 6th highest item in the stack to the top of the stack
|
|
||||
DUP7, ///< copies the 7th highest item in the stack to the top of the stack
|
|
||||
DUP8, ///< copies the 8th highest item in the stack to the top of the stack
|
|
||||
DUP9, ///< copies the 9th highest item in the stack to the top of the stack
|
|
||||
DUP10, ///< copies the 10th highest item in the stack to the top of the stack
|
|
||||
DUP11, ///< copies the 11th highest item in the stack to the top of the stack
|
|
||||
DUP12, ///< copies the 12th highest item in the stack to the top of the stack
|
|
||||
DUP13, ///< copies the 13th highest item in the stack to the top of the stack
|
|
||||
DUP14, ///< copies the 14th highest item in the stack to the top of the stack
|
|
||||
DUP15, ///< copies the 15th highest item in the stack to the top of the stack
|
|
||||
DUP16, ///< copies the 16th highest item in the stack to the top of the stack
|
|
||||
|
|
||||
SWAP1 = 0x90, ///< swaps the highest and second highest value on the stack
|
|
||||
SWAP2, ///< swaps the highest and third highest value on the stack
|
|
||||
SWAP3, ///< swaps the highest and 4th highest value on the stack
|
|
||||
SWAP4, ///< swaps the highest and 5th highest value on the stack
|
|
||||
SWAP5, ///< swaps the highest and 6th highest value on the stack
|
|
||||
SWAP6, ///< swaps the highest and 7th highest value on the stack
|
|
||||
SWAP7, ///< swaps the highest and 8th highest value on the stack
|
|
||||
SWAP8, ///< swaps the highest and 9th highest value on the stack
|
|
||||
SWAP9, ///< swaps the highest and 10th highest value on the stack
|
|
||||
SWAP10, ///< swaps the highest and 11th highest value on the stack
|
|
||||
SWAP11, ///< swaps the highest and 12th highest value on the stack
|
|
||||
SWAP12, ///< swaps the highest and 13th highest value on the stack
|
|
||||
SWAP13, ///< swaps the highest and 14th highest value on the stack
|
|
||||
SWAP14, ///< swaps the highest and 15th highest value on the stack
|
|
||||
SWAP15, ///< swaps the highest and 16th highest value on the stack
|
|
||||
SWAP16, ///< swaps the highest and 17th highest value on the stack
|
|
||||
|
|
||||
LOG0 = 0xa0, ///< Makes a log entry; no topics.
|
|
||||
LOG1, ///< Makes a log entry; 1 topic.
|
|
||||
LOG2, ///< Makes a log entry; 2 topics.
|
|
||||
LOG3, ///< Makes a log entry; 3 topics.
|
|
||||
LOG4, ///< Makes a log entry; 4 topics.
|
|
||||
|
|
||||
CREATE = 0xf0, ///< create a new account with associated code
|
|
||||
CALL, ///< message-call into an account
|
|
||||
CALLCODE, ///< message-call with another account's code only
|
|
||||
RETURN, ///< halt execution returning output data
|
|
||||
SUICIDE = 0xff ///< halt execution and register account for later deletion
|
|
||||
}; |
|
||||
|
|
||||
/// Reads PUSH data from pointed fragment of bytecode and constructs number out of it
|
|
||||
/// Reading out of bytecode means reading 0
|
|
||||
/// @param _curr is updated and points the last real byte read
|
|
||||
llvm::APInt readPushData(code_iterator& _curr, code_iterator _end); |
|
||||
|
|
||||
/// Skips PUSH data in pointed fragment of bytecode.
|
|
||||
/// @param _curr is updated and points the last real byte skipped
|
|
||||
void skipPushData(code_iterator& _curr, code_iterator _end); |
|
||||
|
|
||||
#define ANY_PUSH PUSH1: \ |
|
||||
case Instruction::PUSH2: \ |
|
||||
case Instruction::PUSH3: \ |
|
||||
case Instruction::PUSH4: \ |
|
||||
case Instruction::PUSH5: \ |
|
||||
case Instruction::PUSH6: \ |
|
||||
case Instruction::PUSH7: \ |
|
||||
case Instruction::PUSH8: \ |
|
||||
case Instruction::PUSH9: \ |
|
||||
case Instruction::PUSH10: \ |
|
||||
case Instruction::PUSH11: \ |
|
||||
case Instruction::PUSH12: \ |
|
||||
case Instruction::PUSH13: \ |
|
||||
case Instruction::PUSH14: \ |
|
||||
case Instruction::PUSH15: \ |
|
||||
case Instruction::PUSH16: \ |
|
||||
case Instruction::PUSH17: \ |
|
||||
case Instruction::PUSH18: \ |
|
||||
case Instruction::PUSH19: \ |
|
||||
case Instruction::PUSH20: \ |
|
||||
case Instruction::PUSH21: \ |
|
||||
case Instruction::PUSH22: \ |
|
||||
case Instruction::PUSH23: \ |
|
||||
case Instruction::PUSH24: \ |
|
||||
case Instruction::PUSH25: \ |
|
||||
case Instruction::PUSH26: \ |
|
||||
case Instruction::PUSH27: \ |
|
||||
case Instruction::PUSH28: \ |
|
||||
case Instruction::PUSH29: \ |
|
||||
case Instruction::PUSH30: \ |
|
||||
case Instruction::PUSH31: \ |
|
||||
case Instruction::PUSH32 |
|
||||
|
|
||||
#define ANY_DUP DUP1: \ |
|
||||
case Instruction::DUP2: \ |
|
||||
case Instruction::DUP3: \ |
|
||||
case Instruction::DUP4: \ |
|
||||
case Instruction::DUP5: \ |
|
||||
case Instruction::DUP6: \ |
|
||||
case Instruction::DUP7: \ |
|
||||
case Instruction::DUP8: \ |
|
||||
case Instruction::DUP9: \ |
|
||||
case Instruction::DUP10: \ |
|
||||
case Instruction::DUP11: \ |
|
||||
case Instruction::DUP12: \ |
|
||||
case Instruction::DUP13: \ |
|
||||
case Instruction::DUP14: \ |
|
||||
case Instruction::DUP15: \ |
|
||||
case Instruction::DUP16 |
|
||||
|
|
||||
#define ANY_SWAP SWAP1: \ |
|
||||
case Instruction::SWAP2: \ |
|
||||
case Instruction::SWAP3: \ |
|
||||
case Instruction::SWAP4: \ |
|
||||
case Instruction::SWAP5: \ |
|
||||
case Instruction::SWAP6: \ |
|
||||
case Instruction::SWAP7: \ |
|
||||
case Instruction::SWAP8: \ |
|
||||
case Instruction::SWAP9: \ |
|
||||
case Instruction::SWAP10: \ |
|
||||
case Instruction::SWAP11: \ |
|
||||
case Instruction::SWAP12: \ |
|
||||
case Instruction::SWAP13: \ |
|
||||
case Instruction::SWAP14: \ |
|
||||
case Instruction::SWAP15: \ |
|
||||
case Instruction::SWAP16 |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,48 +0,0 @@ |
|||||
#include <evmjit/JIT-c.h> |
|
||||
#include <cassert> |
|
||||
#include <evmjit/JIT.h> |
|
||||
|
|
||||
extern "C" |
|
||||
{ |
|
||||
using namespace dev::evmjit; |
|
||||
|
|
||||
evmjit_context* evmjit_create(evmjit_runtime_data* _data, void* _env) |
|
||||
{ |
|
||||
auto data = reinterpret_cast<RuntimeData*>(_data); |
|
||||
auto env = reinterpret_cast<Env*>(_env); |
|
||||
|
|
||||
assert(!data && "Pointer to runtime data must not be null"); |
|
||||
if (!data) |
|
||||
return nullptr; |
|
||||
|
|
||||
// TODO: Make sure ExecutionEngine constructor does not throw + make JIT/ExecutionEngine interface all nothrow
|
|
||||
auto context = new(std::nothrow) ExecutionContext{*data, env}; |
|
||||
return reinterpret_cast<evmjit_context*>(context); |
|
||||
} |
|
||||
|
|
||||
void evmjit_destroy(evmjit_context* _context) |
|
||||
{ |
|
||||
auto context = reinterpret_cast<ExecutionContext*>(_context); |
|
||||
delete context; |
|
||||
} |
|
||||
|
|
||||
evmjit_return_code evmjit_exec(evmjit_context* _context) |
|
||||
{ |
|
||||
auto context = reinterpret_cast<ExecutionContext*>(_context); |
|
||||
|
|
||||
assert(!context && "Invalid context"); |
|
||||
if (!context) |
|
||||
return UnexpectedException; |
|
||||
|
|
||||
try |
|
||||
{ |
|
||||
auto returnCode = JIT::exec(*context); |
|
||||
return static_cast<evmjit_return_code>(returnCode); |
|
||||
} |
|
||||
catch(...) |
|
||||
{ |
|
||||
return UnexpectedException; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
@ -1,252 +0,0 @@ |
|||||
#include "evmjit/JIT.h" |
|
||||
|
|
||||
#include <array> |
|
||||
#include <mutex> |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Module.h> |
|
||||
#include <llvm/ADT/Triple.h> |
|
||||
#include <llvm/ExecutionEngine/MCJIT.h> |
|
||||
#include <llvm/Support/TargetSelect.h> |
|
||||
#include <llvm/Support/Host.h> |
|
||||
#include <llvm/Support/CommandLine.h> |
|
||||
#include <llvm/Support/ManagedStatic.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Compiler.h" |
|
||||
#include "Optimizer.h" |
|
||||
#include "Cache.h" |
|
||||
#include "ExecStats.h" |
|
||||
#include "Utils.h" |
|
||||
#include "BuildInfo.gen.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
using namespace eth::jit; |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
using ExecFunc = ReturnCode(*)(ExecutionContext*); |
|
||||
|
|
||||
std::string hash2str(i256 const& _hash) |
|
||||
{ |
|
||||
static const auto size = sizeof(_hash); |
|
||||
static const auto hexChars = "0123456789abcdef"; |
|
||||
std::string str; |
|
||||
str.resize(size * 2); |
|
||||
auto outIt = str.rbegin(); // reverse for BE
|
|
||||
auto& arr = *(std::array<byte, size>*)&_hash; |
|
||||
for (auto b : arr) |
|
||||
{ |
|
||||
*(outIt++) = hexChars[b & 0xf]; |
|
||||
*(outIt++) = hexChars[b >> 4]; |
|
||||
} |
|
||||
return str; |
|
||||
} |
|
||||
|
|
||||
void printVersion() |
|
||||
{ |
|
||||
std::cout << "Ethereum EVM JIT Compiler (http://github.com/ethereum/evmjit):\n" |
|
||||
<< " EVMJIT version " << EVMJIT_VERSION << "\n" |
|
||||
#ifdef NDEBUG |
|
||||
<< " Optimized build, " |
|
||||
#else |
|
||||
<< " DEBUG build, " |
|
||||
#endif |
|
||||
<< __DATE__ << " (" << __TIME__ << ")\n" |
|
||||
<< std::endl; |
|
||||
} |
|
||||
|
|
||||
namespace cl = llvm::cl; |
|
||||
cl::opt<bool> g_optimize{"O", cl::desc{"Optimize"}}; |
|
||||
cl::opt<CacheMode> g_cache{"cache", cl::desc{"Cache compiled EVM code on disk"}, |
|
||||
cl::values( |
|
||||
clEnumValN(CacheMode::on, "1", "Enabled"), |
|
||||
clEnumValN(CacheMode::off, "0", "Disabled"), |
|
||||
clEnumValN(CacheMode::read, "r", "Read only. No new objects are added to cache."), |
|
||||
clEnumValN(CacheMode::write, "w", "Write only. No objects are loaded from cache."), |
|
||||
clEnumValN(CacheMode::clear, "c", "Clear the cache storage. Cache is disabled."), |
|
||||
clEnumValN(CacheMode::preload, "p", "Preload all cached objects."), |
|
||||
clEnumValEnd)}; |
|
||||
cl::opt<bool> g_stats{"st", cl::desc{"Statistics"}}; |
|
||||
cl::opt<bool> g_dump{"dump", cl::desc{"Dump LLVM IR module"}}; |
|
||||
|
|
||||
void parseOptions() |
|
||||
{ |
|
||||
static llvm::llvm_shutdown_obj shutdownObj{}; |
|
||||
cl::AddExtraVersionPrinter(printVersion); |
|
||||
cl::ParseEnvironmentOptions("evmjit", "EVMJIT", "Ethereum EVM JIT Compiler"); |
|
||||
} |
|
||||
|
|
||||
class JITImpl |
|
||||
{ |
|
||||
std::unique_ptr<llvm::ExecutionEngine> m_engine; |
|
||||
mutable std::mutex x_codeMap; |
|
||||
std::unordered_map<h256, ExecFunc> m_codeMap; |
|
||||
|
|
||||
public: |
|
||||
static JITImpl& instance() |
|
||||
{ |
|
||||
static JITImpl s_instance; |
|
||||
return s_instance; |
|
||||
} |
|
||||
|
|
||||
JITImpl(); |
|
||||
|
|
||||
llvm::ExecutionEngine& engine() { return *m_engine; } |
|
||||
|
|
||||
ExecFunc getExecFunc(h256 const& _codeHash) const; |
|
||||
void mapExecFunc(h256 _codeHash, ExecFunc _funcAddr); |
|
||||
|
|
||||
ExecFunc compile(byte const* _code, uint64_t _codeSize, h256 const& _codeHash); |
|
||||
}; |
|
||||
|
|
||||
JITImpl::JITImpl() |
|
||||
{ |
|
||||
parseOptions(); |
|
||||
|
|
||||
bool preloadCache = g_cache == CacheMode::preload; |
|
||||
if (preloadCache) |
|
||||
g_cache = CacheMode::on; |
|
||||
|
|
||||
llvm::InitializeNativeTarget(); |
|
||||
llvm::InitializeNativeTargetAsmPrinter(); |
|
||||
|
|
||||
auto module = std::unique_ptr<llvm::Module>(new llvm::Module({}, llvm::getGlobalContext())); |
|
||||
|
|
||||
// FIXME: LLVM 3.7: test on Windows
|
|
||||
auto triple = llvm::Triple(llvm::sys::getProcessTriple()); |
|
||||
if (triple.getOS() == llvm::Triple::OSType::Win32) |
|
||||
triple.setObjectFormat(llvm::Triple::ObjectFormatType::ELF); // MCJIT does not support COFF format
|
|
||||
module->setTargetTriple(triple.str()); |
|
||||
|
|
||||
llvm::EngineBuilder builder(std::move(module)); |
|
||||
builder.setEngineKind(llvm::EngineKind::JIT); |
|
||||
builder.setOptLevel(g_optimize ? llvm::CodeGenOpt::Default : llvm::CodeGenOpt::None); |
|
||||
|
|
||||
m_engine.reset(builder.create()); |
|
||||
|
|
||||
// TODO: Update cache listener
|
|
||||
m_engine->setObjectCache(Cache::init(g_cache, nullptr)); |
|
||||
|
|
||||
// FIXME: Disabled during API changes
|
|
||||
//if (preloadCache)
|
|
||||
// Cache::preload(*m_engine, funcCache);
|
|
||||
} |
|
||||
|
|
||||
ExecFunc JITImpl::getExecFunc(h256 const& _codeHash) const |
|
||||
{ |
|
||||
std::lock_guard<std::mutex> lock{x_codeMap}; |
|
||||
auto it = m_codeMap.find(_codeHash); |
|
||||
if (it != m_codeMap.end()) |
|
||||
return it->second; |
|
||||
return nullptr; |
|
||||
} |
|
||||
|
|
||||
void JITImpl::mapExecFunc(h256 _codeHash, ExecFunc _funcAddr) |
|
||||
{ |
|
||||
std::lock_guard<std::mutex> lock{x_codeMap}; |
|
||||
m_codeMap.emplace(std::move(_codeHash), _funcAddr); |
|
||||
} |
|
||||
|
|
||||
ExecFunc JITImpl::compile(byte const* _code, uint64_t _codeSize, h256 const& _codeHash) |
|
||||
{ |
|
||||
auto name = hash2str(_codeHash); |
|
||||
auto module = Cache::getObject(name); |
|
||||
if (!module) |
|
||||
{ |
|
||||
// TODO: Listener support must be redesigned. These should be a feature of JITImpl
|
|
||||
//listener->stateChanged(ExecState::Compilation);
|
|
||||
assert(_code || !_codeSize); //TODO: Is it good idea to execute empty code?
|
|
||||
module = Compiler{{}}.compile(_code, _code + _codeSize, name); |
|
||||
|
|
||||
if (g_optimize) |
|
||||
{ |
|
||||
//listener->stateChanged(ExecState::Optimization);
|
|
||||
optimize(*module); |
|
||||
} |
|
||||
|
|
||||
prepare(*module); |
|
||||
} |
|
||||
if (g_dump) |
|
||||
module->dump(); |
|
||||
|
|
||||
m_engine->addModule(std::move(module)); |
|
||||
//listener->stateChanged(ExecState::CodeGen);
|
|
||||
return (ExecFunc)m_engine->getFunctionAddress(name); |
|
||||
} |
|
||||
|
|
||||
} // anonymous namespace
|
|
||||
|
|
||||
bool JIT::isCodeReady(h256 const& _codeHash) |
|
||||
{ |
|
||||
return JITImpl::instance().getExecFunc(_codeHash) != nullptr; |
|
||||
} |
|
||||
|
|
||||
void JIT::compile(byte const* _code, uint64_t _codeSize, h256 const& _codeHash) |
|
||||
{ |
|
||||
auto& jit = JITImpl::instance(); |
|
||||
auto execFunc = jit.compile(_code, _codeSize, _codeHash); |
|
||||
if (execFunc) // FIXME: What with error?
|
|
||||
jit.mapExecFunc(_codeHash, execFunc); |
|
||||
} |
|
||||
|
|
||||
ReturnCode JIT::exec(ExecutionContext& _context) |
|
||||
{ |
|
||||
//std::unique_ptr<ExecStats> listener{new ExecStats};
|
|
||||
//listener->stateChanged(ExecState::Started);
|
|
||||
//static StatsCollector statsCollector;
|
|
||||
|
|
||||
auto& jit = JITImpl::instance(); |
|
||||
auto codeHash = _context.codeHash(); |
|
||||
auto execFunc = jit.getExecFunc(codeHash); |
|
||||
if (!execFunc) |
|
||||
{ |
|
||||
execFunc = jit.compile(_context.code(), _context.codeSize(), codeHash); |
|
||||
if (!execFunc) |
|
||||
return ReturnCode::LLVMError; |
|
||||
jit.mapExecFunc(codeHash, execFunc); |
|
||||
} |
|
||||
|
|
||||
//listener->stateChanged(ExecState::Execution);
|
|
||||
auto returnCode = execFunc(&_context); |
|
||||
//listener->stateChanged(ExecState::Return);
|
|
||||
|
|
||||
if (returnCode == ReturnCode::Return) |
|
||||
_context.returnData = _context.getReturnData(); // Save reference to return data
|
|
||||
|
|
||||
//listener->stateChanged(ExecState::Finished);
|
|
||||
// if (g_stats)
|
|
||||
// statsCollector.stats.push_back(std::move(listener));
|
|
||||
|
|
||||
return returnCode; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
extern "C" void ext_free(void* _data) noexcept; |
|
||||
|
|
||||
ExecutionContext::~ExecutionContext() noexcept |
|
||||
{ |
|
||||
if (m_memData) |
|
||||
ext_free(m_memData); // Use helper free to check memory leaks
|
|
||||
} |
|
||||
|
|
||||
bytes_ref ExecutionContext::getReturnData() const |
|
||||
{ |
|
||||
auto data = m_data->callData; |
|
||||
auto size = static_cast<size_t>(m_data->callDataSize); |
|
||||
|
|
||||
if (data < m_memData || data >= m_memData + m_memSize || size == 0) |
|
||||
{ |
|
||||
assert(size == 0); // data can be an invalid pointer only if size is 0
|
|
||||
m_data->callData = nullptr; |
|
||||
return {}; |
|
||||
} |
|
||||
|
|
||||
return bytes_ref{data, size}; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
@ -1,246 +0,0 @@ |
|||||
#include "Memory.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Type.h" |
|
||||
#include "GasMeter.h" |
|
||||
#include "Endianness.h" |
|
||||
#include "RuntimeManager.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
Memory::Memory(RuntimeManager& _runtimeManager, GasMeter& _gasMeter): |
|
||||
RuntimeHelper(_runtimeManager), // TODO: RuntimeHelper not needed
|
|
||||
m_memory{getBuilder(), _runtimeManager.getMem()}, |
|
||||
m_gasMeter(_gasMeter) |
|
||||
{} |
|
||||
|
|
||||
llvm::Function* Memory::getRequireFunc() |
|
||||
{ |
|
||||
auto& func = m_require; |
|
||||
if (!func) |
|
||||
{ |
|
||||
llvm::Type* argTypes[] = {Array::getType()->getPointerTo(), Type::Word, Type::Word, Type::BytePtr, Type::GasPtr}; |
|
||||
func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "mem.require", getModule()); |
|
||||
func->setDoesNotThrow(); |
|
||||
|
|
||||
auto mem = &func->getArgumentList().front(); |
|
||||
mem->setName("mem"); |
|
||||
auto blkOffset = mem->getNextNode(); |
|
||||
blkOffset->setName("blkOffset"); |
|
||||
auto blkSize = blkOffset->getNextNode(); |
|
||||
blkSize->setName("blkSize"); |
|
||||
auto jmpBuf = blkSize->getNextNode(); |
|
||||
jmpBuf->setName("jmpBuf"); |
|
||||
auto gas = jmpBuf->getNextNode(); |
|
||||
gas->setName("gas"); |
|
||||
|
|
||||
auto preBB = llvm::BasicBlock::Create(func->getContext(), "Pre", func); |
|
||||
auto checkBB = llvm::BasicBlock::Create(func->getContext(), "Check", func); |
|
||||
auto resizeBB = llvm::BasicBlock::Create(func->getContext(), "Resize", func); |
|
||||
auto returnBB = llvm::BasicBlock::Create(func->getContext(), "Return", func); |
|
||||
|
|
||||
InsertPointGuard guard(m_builder); // Restores insert point at function exit
|
|
||||
|
|
||||
// BB "Pre": Ignore checks with size 0
|
|
||||
m_builder.SetInsertPoint(preBB); |
|
||||
m_builder.CreateCondBr(m_builder.CreateICmpNE(blkSize, Constant::get(0)), checkBB, returnBB, Type::expectTrue); |
|
||||
|
|
||||
// BB "Check"
|
|
||||
m_builder.SetInsertPoint(checkBB); |
|
||||
static const auto c_inputMax = uint64_t(1) << 33; // max value of blkSize and blkOffset that will not result in integer overflow in calculations below
|
|
||||
auto blkOffsetOk = m_builder.CreateICmpULE(blkOffset, Constant::get(c_inputMax), "blkOffsetOk"); |
|
||||
auto blkO = m_builder.CreateSelect(blkOffsetOk, m_builder.CreateTrunc(blkOffset, Type::Size), m_builder.getInt64(c_inputMax), "bklO"); |
|
||||
auto blkSizeOk = m_builder.CreateICmpULE(blkSize, Constant::get(c_inputMax), "blkSizeOk"); |
|
||||
auto blkS = m_builder.CreateSelect(blkSizeOk, m_builder.CreateTrunc(blkSize, Type::Size), m_builder.getInt64(c_inputMax), "bklS"); |
|
||||
|
|
||||
auto sizeReq0 = m_builder.CreateNUWAdd(blkO, blkS, "sizeReq0"); |
|
||||
auto sizeReq = m_builder.CreateAnd(m_builder.CreateNUWAdd(sizeReq0, m_builder.getInt64(31)), uint64_t(-1) << 5, "sizeReq"); // s' = ((s0 + 31) / 32) * 32
|
|
||||
auto sizeCur = m_memory.size(mem); |
|
||||
auto sizeOk = m_builder.CreateICmpULE(sizeReq, sizeCur, "sizeOk"); |
|
||||
|
|
||||
m_builder.CreateCondBr(sizeOk, returnBB, resizeBB, Type::expectTrue); |
|
||||
|
|
||||
// BB "Resize"
|
|
||||
m_builder.SetInsertPoint(resizeBB); |
|
||||
// Check gas first
|
|
||||
auto w1 = m_builder.CreateLShr(sizeReq, 5); |
|
||||
auto w1s = m_builder.CreateNUWMul(w1, w1); |
|
||||
auto c1 = m_builder.CreateAdd(m_builder.CreateNUWMul(w1, m_builder.getInt64(3)), m_builder.CreateLShr(w1s, 9)); |
|
||||
auto w0 = m_builder.CreateLShr(sizeCur, 5); |
|
||||
auto w0s = m_builder.CreateNUWMul(w0, w0); |
|
||||
auto c0 = m_builder.CreateAdd(m_builder.CreateNUWMul(w0, m_builder.getInt64(3)), m_builder.CreateLShr(w0s, 9)); |
|
||||
auto cc = m_builder.CreateNUWSub(c1, c0); |
|
||||
auto costOk = m_builder.CreateAnd(blkOffsetOk, blkSizeOk, "costOk"); |
|
||||
auto c = m_builder.CreateSelect(costOk, cc, m_builder.getInt64(std::numeric_limits<int64_t>::max()), "c"); |
|
||||
m_gasMeter.count(c, jmpBuf, gas); |
|
||||
// Resize
|
|
||||
m_memory.extend(mem, sizeReq); |
|
||||
m_builder.CreateBr(returnBB); |
|
||||
|
|
||||
// BB "Return"
|
|
||||
m_builder.SetInsertPoint(returnBB); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
} |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Memory::createFunc(bool _isStore, llvm::Type* _valueType) |
|
||||
{ |
|
||||
auto isWord = _valueType == Type::Word; |
|
||||
|
|
||||
llvm::Type* storeArgs[] = {Array::getType()->getPointerTo(), Type::Word, _valueType}; |
|
||||
llvm::Type* loadArgs[] = {Array::getType()->getPointerTo(), Type::Word}; |
|
||||
auto name = _isStore ? isWord ? "mstore" : "mstore8" : "mload"; |
|
||||
auto funcType = _isStore ? llvm::FunctionType::get(Type::Void, storeArgs, false) : llvm::FunctionType::get(Type::Word, loadArgs, false); |
|
||||
auto func = llvm::Function::Create(funcType, llvm::Function::PrivateLinkage, name, getModule()); |
|
||||
|
|
||||
InsertPointGuard guard(m_builder); // Restores insert point at function exit
|
|
||||
|
|
||||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(func->getContext(), {}, func)); |
|
||||
auto mem = &func->getArgumentList().front(); |
|
||||
mem->setName("mem"); |
|
||||
auto index = mem->getNextNode(); |
|
||||
index->setName("index"); |
|
||||
|
|
||||
if (_isStore) |
|
||||
{ |
|
||||
auto valueArg = index->getNextNode(); |
|
||||
valueArg->setName("value"); |
|
||||
auto value = isWord ? Endianness::toBE(m_builder, valueArg) : valueArg; |
|
||||
auto memPtr = m_memory.getPtr(mem, m_builder.CreateTrunc(index, Type::Size)); |
|
||||
auto valuePtr = m_builder.CreateBitCast(memPtr, _valueType->getPointerTo(), "valuePtr"); |
|
||||
m_builder.CreateStore(value, valuePtr); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
auto memPtr = m_memory.getPtr(mem, m_builder.CreateTrunc(index, Type::Size)); |
|
||||
llvm::Value* ret = m_builder.CreateLoad(memPtr); |
|
||||
ret = Endianness::toNative(m_builder, ret); |
|
||||
m_builder.CreateRet(ret); |
|
||||
} |
|
||||
|
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Memory::getLoadWordFunc() |
|
||||
{ |
|
||||
auto& func = m_loadWord; |
|
||||
if (!func) |
|
||||
func = createFunc(false, Type::Word); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Memory::getStoreWordFunc() |
|
||||
{ |
|
||||
auto& func = m_storeWord; |
|
||||
if (!func) |
|
||||
func = createFunc(true, Type::Word); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
llvm::Function* Memory::getStoreByteFunc() |
|
||||
{ |
|
||||
auto& func = m_storeByte; |
|
||||
if (!func) |
|
||||
func = createFunc(true, Type::Byte); |
|
||||
return func; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
llvm::Value* Memory::loadWord(llvm::Value* _addr) |
|
||||
{ |
|
||||
require(_addr, Constant::get(Type::Word->getPrimitiveSizeInBits() / 8)); |
|
||||
return createCall(getLoadWordFunc(), {getRuntimeManager().getMem(), _addr}); |
|
||||
} |
|
||||
|
|
||||
void Memory::storeWord(llvm::Value* _addr, llvm::Value* _word) |
|
||||
{ |
|
||||
require(_addr, Constant::get(Type::Word->getPrimitiveSizeInBits() / 8)); |
|
||||
createCall(getStoreWordFunc(), {getRuntimeManager().getMem(), _addr, _word}); |
|
||||
} |
|
||||
|
|
||||
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _word) |
|
||||
{ |
|
||||
require(_addr, Constant::get(Type::Byte->getPrimitiveSizeInBits() / 8)); |
|
||||
auto byte = m_builder.CreateTrunc(_word, Type::Byte, "byte"); |
|
||||
createCall(getStoreByteFunc(), {getRuntimeManager().getMem(), _addr, byte}); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Memory::getData() |
|
||||
{ |
|
||||
auto memPtr = m_builder.CreateBitCast(getRuntimeManager().getMem(), Type::BytePtr->getPointerTo()); |
|
||||
auto data = m_builder.CreateLoad(memPtr, "data"); |
|
||||
assert(data->getType() == Type::BytePtr); |
|
||||
return data; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* Memory::getSize() |
|
||||
{ |
|
||||
return m_builder.CreateZExt(m_memory.size(), Type::Word, "msize"); // TODO: Allow placing i64 on stack
|
|
||||
} |
|
||||
|
|
||||
llvm::Value* Memory::getBytePtr(llvm::Value* _index) |
|
||||
{ |
|
||||
return m_builder.CreateGEP(getData(), _index, "ptr"); |
|
||||
} |
|
||||
|
|
||||
void Memory::require(llvm::Value* _offset, llvm::Value* _size) |
|
||||
{ |
|
||||
if (auto constant = llvm::dyn_cast<llvm::ConstantInt>(_size)) |
|
||||
{ |
|
||||
if (!constant->getValue()) |
|
||||
return; |
|
||||
} |
|
||||
createCall(getRequireFunc(), {getRuntimeManager().getMem(), _offset, _size, getRuntimeManager().getJmpBuf(), getRuntimeManager().getGasPtr()}); |
|
||||
} |
|
||||
|
|
||||
void Memory::copyBytes(llvm::Value* _srcPtr, llvm::Value* _srcSize, llvm::Value* _srcIdx, |
|
||||
llvm::Value* _destMemIdx, llvm::Value* _reqBytes) |
|
||||
{ |
|
||||
require(_destMemIdx, _reqBytes); |
|
||||
|
|
||||
// Additional copy cost
|
|
||||
// TODO: This round ups to 32 happens in many places
|
|
||||
auto reqBytes = m_builder.CreateTrunc(_reqBytes, Type::Gas); |
|
||||
auto copyWords = m_builder.CreateUDiv(m_builder.CreateNUWAdd(reqBytes, m_builder.getInt64(31)), m_builder.getInt64(32)); |
|
||||
m_gasMeter.countCopy(copyWords); |
|
||||
|
|
||||
// Algorithm:
|
|
||||
// isOutsideData = idx256 >= size256
|
|
||||
// idx64 = trunc idx256
|
|
||||
// size64 = trunc size256
|
|
||||
// dataLeftSize = size64 - idx64 // safe if not isOutsideData
|
|
||||
// reqBytes64 = trunc _reqBytes // require() handles large values
|
|
||||
// bytesToCopy0 = select(reqBytes64 > dataLeftSize, dataSizeLeft, reqBytes64) // min
|
|
||||
// bytesToCopy = select(isOutsideData, 0, bytesToCopy0)
|
|
||||
|
|
||||
auto isOutsideData = m_builder.CreateICmpUGE(_srcIdx, _srcSize); |
|
||||
auto idx64 = m_builder.CreateTrunc(_srcIdx, Type::Size); |
|
||||
auto size64 = m_builder.CreateTrunc(_srcSize, Type::Size); |
|
||||
auto dataLeftSize = m_builder.CreateNUWSub(size64, idx64); |
|
||||
auto outOfBound = m_builder.CreateICmpUGT(reqBytes, dataLeftSize); |
|
||||
auto bytesToCopyInner = m_builder.CreateSelect(outOfBound, dataLeftSize, reqBytes); |
|
||||
auto bytesToCopy = m_builder.CreateSelect(isOutsideData, m_builder.getInt64(0), bytesToCopyInner, "bytesToCopy"); |
|
||||
auto bytesToZero = m_builder.CreateNUWSub(reqBytes, bytesToCopy, "bytesToZero"); |
|
||||
|
|
||||
auto src = m_builder.CreateGEP(_srcPtr, idx64, "src"); |
|
||||
auto dstIdx = m_builder.CreateTrunc(_destMemIdx, Type::Size, "dstIdx"); |
|
||||
auto padIdx = m_builder.CreateNUWAdd(dstIdx, bytesToCopy, "padIdx"); |
|
||||
auto dst = m_memory.getPtr(getRuntimeManager().getMem(), dstIdx); |
|
||||
auto pad = m_memory.getPtr(getRuntimeManager().getMem(), padIdx); |
|
||||
m_builder.CreateMemCpy(dst, src, bytesToCopy, 0); |
|
||||
m_builder.CreateMemSet(pad, m_builder.getInt8(0), bytesToZero, 0); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,51 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "Array.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
class GasMeter; |
|
||||
|
|
||||
class Memory : public RuntimeHelper |
|
||||
{ |
|
||||
public: |
|
||||
Memory(RuntimeManager& _runtimeManager, GasMeter& _gasMeter); |
|
||||
|
|
||||
llvm::Value* loadWord(llvm::Value* _addr); |
|
||||
void storeWord(llvm::Value* _addr, llvm::Value* _word); |
|
||||
void storeByte(llvm::Value* _addr, llvm::Value* _byte); |
|
||||
llvm::Value* getData(); |
|
||||
llvm::Value* getSize(); |
|
||||
llvm::Value* getBytePtr(llvm::Value* _index); |
|
||||
void copyBytes(llvm::Value* _srcPtr, llvm::Value* _srcSize, llvm::Value* _srcIndex, |
|
||||
llvm::Value* _destMemIdx, llvm::Value* _byteCount); |
|
||||
|
|
||||
/// 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); |
|
||||
|
|
||||
private: |
|
||||
Array m_memory; |
|
||||
|
|
||||
GasMeter& m_gasMeter; |
|
||||
|
|
||||
llvm::Function* createFunc(bool _isStore, llvm::Type* _type); |
|
||||
|
|
||||
llvm::Function* getRequireFunc(); |
|
||||
llvm::Function* getLoadWordFunc(); |
|
||||
llvm::Function* getStoreWordFunc(); |
|
||||
llvm::Function* getStoreByteFunc(); |
|
||||
|
|
||||
llvm::Function* m_require = nullptr; |
|
||||
llvm::Function* m_loadWord = nullptr; |
|
||||
llvm::Function* m_storeWord = nullptr; |
|
||||
llvm::Function* m_storeByte = nullptr; |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,125 +0,0 @@ |
|||||
#include "Optimizer.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/BasicBlock.h> |
|
||||
#include <llvm/IR/Function.h> |
|
||||
#include <llvm/IR/LegacyPassManager.h> |
|
||||
#include <llvm/Transforms/Scalar.h> |
|
||||
#include <llvm/Transforms/IPO.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Arith256.h" |
|
||||
#include "Type.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
bool optimize(llvm::Module& _module) |
|
||||
{ |
|
||||
auto pm = llvm::legacy::PassManager{}; |
|
||||
pm.add(llvm::createFunctionInliningPass(2, 2)); |
|
||||
pm.add(llvm::createCFGSimplificationPass()); |
|
||||
pm.add(llvm::createInstructionCombiningPass()); |
|
||||
pm.add(llvm::createAggressiveDCEPass()); |
|
||||
pm.add(llvm::createLowerSwitchPass()); |
|
||||
return pm.run(_module); |
|
||||
} |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
|
|
||||
class LowerEVMPass: public llvm::BasicBlockPass |
|
||||
{ |
|
||||
static char ID; |
|
||||
|
|
||||
public: |
|
||||
LowerEVMPass(): |
|
||||
llvm::BasicBlockPass(ID) |
|
||||
{} |
|
||||
|
|
||||
virtual bool runOnBasicBlock(llvm::BasicBlock& _bb) override; |
|
||||
|
|
||||
using llvm::BasicBlockPass::doFinalization; |
|
||||
virtual bool doFinalization(llvm::Module& _module) override; |
|
||||
}; |
|
||||
|
|
||||
char LowerEVMPass::ID = 0; |
|
||||
|
|
||||
bool LowerEVMPass::runOnBasicBlock(llvm::BasicBlock& _bb) |
|
||||
{ |
|
||||
auto modified = false; |
|
||||
auto module = _bb.getParent()->getParent(); |
|
||||
auto i512Ty = llvm::IntegerType::get(_bb.getContext(), 512); |
|
||||
for (auto it = _bb.begin(); it != _bb.end(); ) |
|
||||
{ |
|
||||
auto& inst = *it++; |
|
||||
llvm::Function* func = nullptr; |
|
||||
if (inst.getType() == Type::Word) |
|
||||
{ |
|
||||
switch (inst.getOpcode()) |
|
||||
{ |
|
||||
case llvm::Instruction::Mul: |
|
||||
func = Arith256::getMulFunc(*module); |
|
||||
break; |
|
||||
|
|
||||
case llvm::Instruction::UDiv: |
|
||||
func = Arith256::getUDiv256Func(*module); |
|
||||
break; |
|
||||
|
|
||||
case llvm::Instruction::URem: |
|
||||
func = Arith256::getURem256Func(*module); |
|
||||
break; |
|
||||
|
|
||||
case llvm::Instruction::SDiv: |
|
||||
func = Arith256::getSDiv256Func(*module); |
|
||||
break; |
|
||||
|
|
||||
case llvm::Instruction::SRem: |
|
||||
func = Arith256::getSRem256Func(*module); |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
else if (inst.getType() == i512Ty) |
|
||||
{ |
|
||||
switch (inst.getOpcode()) |
|
||||
{ |
|
||||
case llvm::Instruction::URem: |
|
||||
func = Arith256::getURem512Func(*module); |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if (func) |
|
||||
{ |
|
||||
auto call = llvm::CallInst::Create(func, {inst.getOperand(0), inst.getOperand(1)}, "", &inst); |
|
||||
inst.replaceAllUsesWith(call); |
|
||||
inst.eraseFromParent(); |
|
||||
modified = true; |
|
||||
} |
|
||||
} |
|
||||
return modified; |
|
||||
} |
|
||||
|
|
||||
bool LowerEVMPass::doFinalization(llvm::Module&) |
|
||||
{ |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
|
|
||||
bool prepare(llvm::Module& _module) |
|
||||
{ |
|
||||
auto pm = llvm::legacy::PassManager{}; |
|
||||
pm.add(llvm::createCFGSimplificationPass()); |
|
||||
pm.add(llvm::createDeadCodeEliminationPass()); |
|
||||
pm.add(new LowerEVMPass{}); |
|
||||
return pm.run(_module); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,21 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
namespace llvm |
|
||||
{ |
|
||||
class Module; |
|
||||
} |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
bool optimize(llvm::Module& _module); |
|
||||
|
|
||||
bool prepare(llvm::Module& _module); |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,302 +0,0 @@ |
|||||
#include "RuntimeManager.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/IntrinsicInst.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "Stack.h" |
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
llvm::StructType* RuntimeManager::getRuntimeDataType() |
|
||||
{ |
|
||||
static llvm::StructType* type = nullptr; |
|
||||
if (!type) |
|
||||
{ |
|
||||
llvm::Type* elems[] = |
|
||||
{ |
|
||||
Type::Size, // gas
|
|
||||
Type::Size, // gasPrice
|
|
||||
Type::BytePtr, // callData
|
|
||||
Type::Size, // callDataSize
|
|
||||
Type::Word, // address
|
|
||||
Type::Word, // caller
|
|
||||
Type::Word, // origin
|
|
||||
Type::Word, // callValue
|
|
||||
Type::Word, // coinBase
|
|
||||
Type::Word, // difficulty
|
|
||||
Type::Word, // gasLimit
|
|
||||
Type::Size, // blockNumber
|
|
||||
Type::Size, // blockTimestamp
|
|
||||
Type::BytePtr, // code
|
|
||||
Type::Size, // codeSize
|
|
||||
}; |
|
||||
type = llvm::StructType::create(elems, "RuntimeData"); |
|
||||
} |
|
||||
return type; |
|
||||
} |
|
||||
|
|
||||
llvm::StructType* RuntimeManager::getRuntimeType() |
|
||||
{ |
|
||||
static llvm::StructType* type = nullptr; |
|
||||
if (!type) |
|
||||
{ |
|
||||
llvm::Type* elems[] = |
|
||||
{ |
|
||||
Type::RuntimeDataPtr, // data
|
|
||||
Type::EnvPtr, // Env*
|
|
||||
Array::getType() // memory
|
|
||||
}; |
|
||||
type = llvm::StructType::create(elems, "Runtime"); |
|
||||
} |
|
||||
return type; |
|
||||
} |
|
||||
|
|
||||
namespace |
|
||||
{ |
|
||||
llvm::Twine getName(RuntimeData::Index _index) |
|
||||
{ |
|
||||
switch (_index) |
|
||||
{ |
|
||||
default: return ""; |
|
||||
case RuntimeData::Gas: return "msg.gas"; |
|
||||
case RuntimeData::GasPrice: return "tx.gasprice"; |
|
||||
case RuntimeData::CallData: return "msg.data.ptr"; |
|
||||
case RuntimeData::CallDataSize: return "msg.data.size"; |
|
||||
case RuntimeData::Address: return "this.address"; |
|
||||
case RuntimeData::Caller: return "msg.caller"; |
|
||||
case RuntimeData::Origin: return "tx.origin"; |
|
||||
case RuntimeData::CallValue: return "msg.value"; |
|
||||
case RuntimeData::CoinBase: return "block.coinbase"; |
|
||||
case RuntimeData::Difficulty: return "block.difficulty"; |
|
||||
case RuntimeData::GasLimit: return "block.gaslimit"; |
|
||||
case RuntimeData::Number: return "block.number"; |
|
||||
case RuntimeData::Timestamp: return "block.timestamp"; |
|
||||
case RuntimeData::Code: return "code.ptr"; |
|
||||
case RuntimeData::CodeSize: return "code.size"; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
RuntimeManager::RuntimeManager(llvm::IRBuilder<>& _builder, code_iterator _codeBegin, code_iterator _codeEnd): |
|
||||
CompilerHelper(_builder), |
|
||||
m_codeBegin(_codeBegin), |
|
||||
m_codeEnd(_codeEnd) |
|
||||
{ |
|
||||
m_longjmp = llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::eh_sjlj_longjmp); |
|
||||
|
|
||||
// Unpack data
|
|
||||
auto rtPtr = getRuntimePtr(); |
|
||||
m_dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 0), "dataPtr"); |
|
||||
assert(m_dataPtr->getType() == Type::RuntimeDataPtr); |
|
||||
m_memPtr = m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 2, "mem"); |
|
||||
assert(m_memPtr->getType() == Array::getType()->getPointerTo()); |
|
||||
m_envPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 1), "env"); |
|
||||
assert(m_envPtr->getType() == Type::EnvPtr); |
|
||||
|
|
||||
m_stackSize = m_builder.CreateAlloca(Type::Size, nullptr, "stackSize"); |
|
||||
m_builder.CreateStore(m_builder.getInt64(0), m_stackSize); |
|
||||
|
|
||||
auto data = m_builder.CreateLoad(m_dataPtr, "data"); |
|
||||
for (unsigned i = 0; i < m_dataElts.size(); ++i) |
|
||||
m_dataElts[i] = m_builder.CreateExtractValue(data, i, getName(RuntimeData::Index(i))); |
|
||||
|
|
||||
m_gasPtr = m_builder.CreateAlloca(Type::Gas, nullptr, "gas.ptr"); |
|
||||
m_builder.CreateStore(m_dataElts[RuntimeData::Index::Gas], m_gasPtr); |
|
||||
|
|
||||
llvm::Type* checkStackLimitArgs[] = {Type::Size->getPointerTo(), Type::Size, Type::Size, Type::Size, Type::BytePtr}; |
|
||||
m_checkStackLimit = llvm::Function::Create(llvm::FunctionType::get(Type::Void, checkStackLimitArgs, false), llvm::Function::PrivateLinkage, "evm.stack.require", getModule()); |
|
||||
m_checkStackLimit->setDoesNotThrow(); |
|
||||
m_checkStackLimit->setDoesNotCapture(1); |
|
||||
|
|
||||
auto checkBB = llvm::BasicBlock::Create(_builder.getContext(), "Check", m_checkStackLimit); |
|
||||
auto updateBB = llvm::BasicBlock::Create(_builder.getContext(), "Update", m_checkStackLimit); |
|
||||
auto outOfStackBB = llvm::BasicBlock::Create(_builder.getContext(), "OutOfStack", m_checkStackLimit); |
|
||||
|
|
||||
auto currSizePtr = &m_checkStackLimit->getArgumentList().front(); |
|
||||
currSizePtr->setName("currSize"); |
|
||||
auto min = currSizePtr->getNextNode(); |
|
||||
min->setName("min"); |
|
||||
auto max = min->getNextNode(); |
|
||||
max->setName("max"); |
|
||||
auto diff = max->getNextNode(); |
|
||||
diff->setName("diff"); |
|
||||
auto jmpBuf = diff->getNextNode(); |
|
||||
jmpBuf->setName("jmpBuf"); |
|
||||
|
|
||||
InsertPointGuard guard{m_builder}; |
|
||||
m_builder.SetInsertPoint(checkBB); |
|
||||
auto currSize = m_builder.CreateLoad(currSizePtr, "cur"); |
|
||||
auto minSize = m_builder.CreateAdd(currSize, min, "minSize", false, true); |
|
||||
auto maxSize = m_builder.CreateAdd(currSize, max, "maxSize", true, true); |
|
||||
auto minOk = m_builder.CreateICmpSGE(minSize, m_builder.getInt64(0), "min.ok"); |
|
||||
auto maxOk = m_builder.CreateICmpULE(maxSize, m_builder.getInt64(1024), "max.ok"); |
|
||||
auto ok = m_builder.CreateAnd(minOk, maxOk, "ok"); |
|
||||
m_builder.CreateCondBr(ok, updateBB, outOfStackBB, Type::expectTrue); |
|
||||
|
|
||||
m_builder.SetInsertPoint(updateBB); |
|
||||
auto newSize = m_builder.CreateNSWAdd(currSize, diff); |
|
||||
m_builder.CreateStore(newSize, currSizePtr); |
|
||||
m_builder.CreateRetVoid(); |
|
||||
|
|
||||
m_builder.SetInsertPoint(outOfStackBB); |
|
||||
abort(jmpBuf); |
|
||||
m_builder.CreateUnreachable(); |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::checkStackLimit(ssize_t _min, ssize_t _max, ssize_t _diff) |
|
||||
{ |
|
||||
createCall(m_checkStackLimit, {m_stackSize, m_builder.getInt64(_min), m_builder.getInt64(_max), m_builder.getInt64(_diff), getJmpBuf()}); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getRuntimePtr() |
|
||||
{ |
|
||||
// Expect first argument of a function to be a pointer to Runtime
|
|
||||
auto func = m_builder.GetInsertBlock()->getParent(); |
|
||||
auto rtPtr = &func->getArgumentList().front(); |
|
||||
assert(rtPtr->getType() == Type::RuntimePtr); |
|
||||
return rtPtr; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getDataPtr() |
|
||||
{ |
|
||||
if (getMainFunction()) |
|
||||
return m_dataPtr; |
|
||||
|
|
||||
auto rtPtr = getRuntimePtr(); |
|
||||
auto dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(getRuntimeType(), rtPtr, 0), "data"); |
|
||||
assert(dataPtr->getType() == getRuntimeDataType()->getPointerTo()); |
|
||||
return dataPtr; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getEnvPtr() |
|
||||
{ |
|
||||
assert(getMainFunction()); // Available only in main function
|
|
||||
return m_envPtr; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getPtr(RuntimeData::Index _index) |
|
||||
{ |
|
||||
auto ptr = getBuilder().CreateStructGEP(getRuntimeDataType(), getDataPtr(), _index); |
|
||||
assert(getRuntimeDataType()->getElementType(_index)->getPointerTo() == ptr->getType()); |
|
||||
return ptr; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::get(RuntimeData::Index _index) |
|
||||
{ |
|
||||
return m_dataElts[_index]; |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::set(RuntimeData::Index _index, llvm::Value* _value) |
|
||||
{ |
|
||||
auto ptr = getPtr(_index); |
|
||||
assert(ptr->getType() == _value->getType()->getPointerTo()); |
|
||||
getBuilder().CreateStore(_value, ptr); |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::registerReturnData(llvm::Value* _offset, llvm::Value* _size) |
|
||||
{ |
|
||||
auto memPtr = m_builder.CreateBitCast(getMem(), Type::BytePtr->getPointerTo()); |
|
||||
auto mem = getBuilder().CreateLoad(memPtr, "memory"); |
|
||||
auto returnDataPtr = getBuilder().CreateGEP(mem, _offset); |
|
||||
set(RuntimeData::ReturnData, returnDataPtr); |
|
||||
|
|
||||
auto size64 = getBuilder().CreateTrunc(_size, Type::Size); |
|
||||
set(RuntimeData::ReturnDataSize, size64); |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::registerSuicide(llvm::Value* _balanceAddress) |
|
||||
{ |
|
||||
set(RuntimeData::SuicideDestAddress, _balanceAddress); |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::exit(ReturnCode _returnCode) |
|
||||
{ |
|
||||
if (m_stack) |
|
||||
m_stack->free(); |
|
||||
|
|
||||
auto extGasPtr = m_builder.CreateStructGEP(getRuntimeDataType(), getDataPtr(), RuntimeData::Index::Gas, "msg.gas.ptr"); |
|
||||
m_builder.CreateStore(getGas(), extGasPtr); |
|
||||
m_builder.CreateRet(Constant::get(_returnCode)); |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::abort(llvm::Value* _jmpBuf) |
|
||||
{ |
|
||||
auto longjmp = llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::eh_sjlj_longjmp); |
|
||||
createCall(longjmp, {_jmpBuf}); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::get(Instruction _inst) |
|
||||
{ |
|
||||
switch (_inst) |
|
||||
{ |
|
||||
default: assert(false); return nullptr; |
|
||||
case Instruction::ADDRESS: return get(RuntimeData::Address); |
|
||||
case Instruction::CALLER: return get(RuntimeData::Caller); |
|
||||
case Instruction::ORIGIN: return get(RuntimeData::Origin); |
|
||||
case Instruction::CALLVALUE: return get(RuntimeData::CallValue); |
|
||||
case Instruction::GASPRICE: return get(RuntimeData::GasPrice); |
|
||||
case Instruction::COINBASE: return get(RuntimeData::CoinBase); |
|
||||
case Instruction::DIFFICULTY: return get(RuntimeData::Difficulty); |
|
||||
case Instruction::GASLIMIT: return get(RuntimeData::GasLimit); |
|
||||
case Instruction::NUMBER: return get(RuntimeData::Number); |
|
||||
case Instruction::TIMESTAMP: return get(RuntimeData::Timestamp); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getCallData() |
|
||||
{ |
|
||||
return get(RuntimeData::CallData); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getCode() |
|
||||
{ |
|
||||
// OPT Check what is faster
|
|
||||
//return get(RuntimeData::Code);
|
|
||||
return m_builder.CreateGlobalStringPtr({reinterpret_cast<char const*>(m_codeBegin), static_cast<size_t>(m_codeEnd - m_codeBegin)}, "code"); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getCodeSize() |
|
||||
{ |
|
||||
return Constant::get(m_codeEnd - m_codeBegin); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getCallDataSize() |
|
||||
{ |
|
||||
auto value = get(RuntimeData::CallDataSize); |
|
||||
assert(value->getType() == Type::Size); |
|
||||
return getBuilder().CreateZExt(value, Type::Word); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getGas() |
|
||||
{ |
|
||||
return getBuilder().CreateLoad(getGasPtr(), "gas"); |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getGasPtr() |
|
||||
{ |
|
||||
assert(getMainFunction()); |
|
||||
return m_gasPtr; |
|
||||
} |
|
||||
|
|
||||
llvm::Value* RuntimeManager::getMem() |
|
||||
{ |
|
||||
assert(getMainFunction()); |
|
||||
return m_memPtr; |
|
||||
} |
|
||||
|
|
||||
void RuntimeManager::setGas(llvm::Value* _gas) |
|
||||
{ |
|
||||
assert(_gas->getType() == Type::Gas); |
|
||||
getBuilder().CreateStore(_gas, getGasPtr()); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,79 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <array> |
|
||||
|
|
||||
#include "CompilerHelper.h" |
|
||||
#include "Type.h" |
|
||||
#include "Instruction.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
using namespace evmjit; |
|
||||
class Stack; |
|
||||
|
|
||||
class RuntimeManager: public CompilerHelper |
|
||||
{ |
|
||||
public: |
|
||||
RuntimeManager(llvm::IRBuilder<>& _builder, code_iterator _codeBegin, code_iterator _codeEnd); |
|
||||
|
|
||||
llvm::Value* getRuntimePtr(); |
|
||||
llvm::Value* getDataPtr(); |
|
||||
llvm::Value* getEnvPtr(); |
|
||||
|
|
||||
llvm::Value* get(RuntimeData::Index _index); |
|
||||
llvm::Value* get(Instruction _inst); |
|
||||
llvm::Value* getGas(); |
|
||||
llvm::Value* getGasPtr(); |
|
||||
llvm::Value* getCallData(); |
|
||||
llvm::Value* getCode(); |
|
||||
llvm::Value* getCodeSize(); |
|
||||
llvm::Value* getCallDataSize(); |
|
||||
llvm::Value* getJmpBuf() { return m_jmpBuf; } |
|
||||
void setGas(llvm::Value* _gas); |
|
||||
|
|
||||
llvm::Value* getMem(); |
|
||||
|
|
||||
void registerReturnData(llvm::Value* _index, llvm::Value* _size); // TODO: Move to Memory.
|
|
||||
void registerSuicide(llvm::Value* _balanceAddress); |
|
||||
|
|
||||
void exit(ReturnCode _returnCode); |
|
||||
|
|
||||
void abort(llvm::Value* _jmpBuf); |
|
||||
|
|
||||
void setStack(Stack& _stack) { m_stack = &_stack; } |
|
||||
void setJmpBuf(llvm::Value* _jmpBuf) { m_jmpBuf = _jmpBuf; } |
|
||||
|
|
||||
static llvm::StructType* getRuntimeType(); |
|
||||
static llvm::StructType* getRuntimeDataType(); |
|
||||
|
|
||||
void checkStackLimit(ssize_t _min, ssize_t _max, ssize_t _diff); |
|
||||
|
|
||||
private: |
|
||||
llvm::Value* getPtr(RuntimeData::Index _index); |
|
||||
void set(RuntimeData::Index _index, llvm::Value* _value); |
|
||||
|
|
||||
llvm::Function* m_longjmp = nullptr; |
|
||||
llvm::Value* m_jmpBuf = nullptr; |
|
||||
llvm::Value* m_dataPtr = nullptr; |
|
||||
llvm::Value* m_gasPtr = nullptr; |
|
||||
llvm::Value* m_memPtr = nullptr; |
|
||||
llvm::Value* m_envPtr = nullptr; |
|
||||
|
|
||||
std::array<llvm::Value*, RuntimeData::numElements> m_dataElts; |
|
||||
|
|
||||
llvm::Value* m_stackSize = nullptr; |
|
||||
llvm::Function* m_checkStackLimit = nullptr; |
|
||||
|
|
||||
code_iterator m_codeBegin = {}; |
|
||||
code_iterator m_codeEnd = {}; |
|
||||
|
|
||||
Stack* m_stack = nullptr; |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,44 +0,0 @@ |
|||||
#include "Stack.h" |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Function.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "RuntimeManager.h" |
|
||||
#include "Utils.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
Stack::Stack(llvm::IRBuilder<>& _builder): |
|
||||
CompilerHelper(_builder), |
|
||||
m_stack(_builder, "stack") |
|
||||
{} |
|
||||
|
|
||||
llvm::Value* Stack::get(size_t _index) |
|
||||
{ |
|
||||
return m_stack.get(m_builder.CreateSub(m_stack.size(), m_builder.getInt64(_index + 1))); |
|
||||
} |
|
||||
|
|
||||
void Stack::set(size_t _index, llvm::Value* _value) |
|
||||
{ |
|
||||
m_stack.set(m_builder.CreateSub(m_stack.size(), m_builder.getInt64(_index + 1)), _value); |
|
||||
} |
|
||||
|
|
||||
void Stack::pop(size_t _count) |
|
||||
{ |
|
||||
m_stack.pop(m_builder.getInt64(_count)); |
|
||||
} |
|
||||
|
|
||||
void Stack::push(llvm::Value* _value) |
|
||||
{ |
|
||||
m_stack.push(_value); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,30 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "Array.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
class Stack: public CompilerHelper |
|
||||
{ |
|
||||
public: |
|
||||
Stack(llvm::IRBuilder<>& builder); |
|
||||
|
|
||||
llvm::Value* get(size_t _index); |
|
||||
void set(size_t _index, llvm::Value* _value); |
|
||||
void pop(size_t _count); |
|
||||
void push(llvm::Value* _value); |
|
||||
void free() { m_stack.free(); } |
|
||||
|
|
||||
private: |
|
||||
Array m_stack; |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,73 +0,0 @@ |
|||||
#include "Type.h" |
|
||||
|
|
||||
#include <llvm/IR/MDBuilder.h> |
|
||||
|
|
||||
#include "RuntimeManager.h" |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
|
|
||||
llvm::IntegerType* Type::Word; |
|
||||
llvm::PointerType* Type::WordPtr; |
|
||||
llvm::IntegerType* Type::Bool; |
|
||||
llvm::IntegerType* Type::Size; |
|
||||
llvm::IntegerType* Type::Gas; |
|
||||
llvm::PointerType* Type::GasPtr; |
|
||||
llvm::IntegerType* Type::Byte; |
|
||||
llvm::PointerType* Type::BytePtr; |
|
||||
llvm::Type* Type::Void; |
|
||||
llvm::IntegerType* Type::MainReturn; |
|
||||
llvm::PointerType* Type::EnvPtr; |
|
||||
llvm::PointerType* Type::RuntimeDataPtr; |
|
||||
llvm::PointerType* Type::RuntimePtr; |
|
||||
llvm::ConstantInt* Constant::gasMax; |
|
||||
llvm::MDNode* Type::expectTrue; |
|
||||
|
|
||||
void Type::init(llvm::LLVMContext& _context) |
|
||||
{ |
|
||||
if (!Word) // Do init only once
|
|
||||
{ |
|
||||
Word = llvm::Type::getIntNTy(_context, 256); |
|
||||
WordPtr = Word->getPointerTo(); |
|
||||
Bool = llvm::Type::getInt1Ty(_context); |
|
||||
Size = llvm::Type::getInt64Ty(_context); |
|
||||
Gas = Size; |
|
||||
GasPtr = Gas->getPointerTo(); |
|
||||
Byte = llvm::Type::getInt8Ty(_context); |
|
||||
BytePtr = Byte->getPointerTo(); |
|
||||
Void = llvm::Type::getVoidTy(_context); |
|
||||
MainReturn = llvm::Type::getInt32Ty(_context); |
|
||||
|
|
||||
EnvPtr = llvm::StructType::create(_context, "Env")->getPointerTo(); |
|
||||
RuntimeDataPtr = RuntimeManager::getRuntimeDataType()->getPointerTo(); |
|
||||
RuntimePtr = RuntimeManager::getRuntimeType()->getPointerTo(); |
|
||||
|
|
||||
Constant::gasMax = llvm::ConstantInt::getSigned(Type::Gas, std::numeric_limits<int64_t>::max()); |
|
||||
|
|
||||
expectTrue = llvm::MDBuilder{_context}.createBranchWeights(1, 0); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
llvm::ConstantInt* Constant::get(int64_t _n) |
|
||||
{ |
|
||||
return llvm::ConstantInt::getSigned(Type::Word, _n); |
|
||||
} |
|
||||
|
|
||||
llvm::ConstantInt* Constant::get(llvm::APInt const& _n) |
|
||||
{ |
|
||||
return llvm::ConstantInt::get(Type::Word->getContext(), _n); |
|
||||
} |
|
||||
|
|
||||
llvm::ConstantInt* Constant::get(ReturnCode _returnCode) |
|
||||
{ |
|
||||
return llvm::ConstantInt::get(Type::MainReturn, static_cast<uint64_t>(_returnCode)); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,61 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include "preprocessor/llvm_includes_start.h" |
|
||||
#include <llvm/IR/Type.h> |
|
||||
#include <llvm/IR/Constants.h> |
|
||||
#include <llvm/IR/Metadata.h> |
|
||||
#include "preprocessor/llvm_includes_end.h" |
|
||||
|
|
||||
#include "evmjit/JIT.h" // ReturnCode |
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace eth |
|
||||
{ |
|
||||
namespace jit |
|
||||
{ |
|
||||
using namespace evmjit; |
|
||||
|
|
||||
struct Type |
|
||||
{ |
|
||||
static llvm::IntegerType* Word; |
|
||||
static llvm::PointerType* WordPtr; |
|
||||
|
|
||||
static llvm::IntegerType* Bool; |
|
||||
static llvm::IntegerType* Size; |
|
||||
static llvm::IntegerType* Gas; |
|
||||
static llvm::PointerType* GasPtr; |
|
||||
|
|
||||
static llvm::IntegerType* Byte; |
|
||||
static llvm::PointerType* BytePtr; |
|
||||
|
|
||||
static llvm::Type* Void; |
|
||||
|
|
||||
/// Main function return type
|
|
||||
static llvm::IntegerType* MainReturn; |
|
||||
|
|
||||
static llvm::PointerType* EnvPtr; |
|
||||
static llvm::PointerType* RuntimeDataPtr; |
|
||||
static llvm::PointerType* RuntimePtr; |
|
||||
|
|
||||
// TODO: Redesign static LLVM objects
|
|
||||
static llvm::MDNode* expectTrue; |
|
||||
|
|
||||
static void init(llvm::LLVMContext& _context); |
|
||||
}; |
|
||||
|
|
||||
struct Constant |
|
||||
{ |
|
||||
static llvm::ConstantInt* gasMax; |
|
||||
|
|
||||
/// Returns word-size constant
|
|
||||
static llvm::ConstantInt* get(int64_t _n); |
|
||||
static llvm::ConstantInt* get(llvm::APInt const& _n); |
|
||||
|
|
||||
static llvm::ConstantInt* get(ReturnCode _returnCode); |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
@ -1,27 +0,0 @@ |
|||||
#include "Utils.h" |
|
||||
|
|
||||
#include <llvm/Support/Debug.h> |
|
||||
|
|
||||
#include "BuildInfo.gen.h" |
|
||||
|
|
||||
#if !defined(NDEBUG) // Debug
|
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
std::ostream& getLogStream(char const* _channel) |
|
||||
{ |
|
||||
static std::ostream nullStream{nullptr}; |
|
||||
#if LLVM_DEBUG |
|
||||
return (llvm::DebugFlag && llvm::isCurrentDebugType(_channel)) ? std::cerr : nullStream; |
|
||||
#else |
|
||||
return (void)_channel, nullStream; |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#endif |
|
||||
@ -1,40 +0,0 @@ |
|||||
#pragma once |
|
||||
|
|
||||
#include <iostream> |
|
||||
|
|
||||
// The same as assert, but expression is always evaluated and result returned
|
|
||||
#define CHECK(expr) (assert(expr), expr) |
|
||||
|
|
||||
#if !defined(NDEBUG) // Debug
|
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
std::ostream& getLogStream(char const* _channel); |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#define DLOG(CHANNEL) ::dev::evmjit::getLogStream(#CHANNEL) |
|
||||
|
|
||||
#else // Release
|
|
||||
|
|
||||
namespace dev |
|
||||
{ |
|
||||
namespace evmjit |
|
||||
{ |
|
||||
|
|
||||
struct Voider |
|
||||
{ |
|
||||
void operator=(std::ostream const&) {} |
|
||||
}; |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
#define DLOG(CHANNEL) true ? (void)0 : ::dev::evmjit::Voider{} = std::cerr |
|
||||
|
|
||||
#endif |
|
||||
@ -1,7 +0,0 @@ |
|||||
#if defined(_MSC_VER) |
|
||||
#pragma warning(pop) |
|
||||
#elif defined(__clang__) |
|
||||
#pragma clang diagnostic pop |
|
||||
#else |
|
||||
#pragma GCC diagnostic pop |
|
||||
#endif |
|
||||
@ -1,12 +0,0 @@ |
|||||
#if defined(_MSC_VER) |
|
||||
#pragma warning(push) |
|
||||
#pragma warning(disable: 4267 4244 4800 4624) |
|
||||
#elif defined(__clang__) |
|
||||
#pragma clang diagnostic push |
|
||||
#pragma clang diagnostic ignored "-Wunused-parameter" |
|
||||
#pragma clang diagnostic ignored "-Wconversion" |
|
||||
#else |
|
||||
#pragma GCC diagnostic push |
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter" |
|
||||
#pragma GCC diagnostic ignored "-Wconversion" |
|
||||
#endif |
|
||||
@ -1,38 +0,0 @@ |
|||||
cmake_policy(SET CMP0015 NEW) |
|
||||
set(CMAKE_AUTOMOC OFF) |
|
||||
|
|
||||
aux_source_directory(. SRC_LIST) |
|
||||
|
|
||||
include_directories(BEFORE ${JSONCPP_INCLUDE_DIRS}) |
|
||||
include_directories(BEFORE ..) |
|
||||
include_directories(${DB_INCLUDE_DIRS}) |
|
||||
|
|
||||
set(EXECUTABLE exp) |
|
||||
|
|
||||
add_executable(${EXECUTABLE} ${SRC_LIST}) |
|
||||
|
|
||||
target_link_libraries(${EXECUTABLE} ${Boost_REGEX_LIBRARIES}) |
|
||||
|
|
||||
if (READLINE_FOUND) |
|
||||
target_link_libraries(${EXECUTABLE} ${READLINE_LIBRARIES}) |
|
||||
endif() |
|
||||
|
|
||||
if (JSONRPC) |
|
||||
target_link_libraries(${EXECUTABLE} web3jsonrpc) |
|
||||
endif() |
|
||||
|
|
||||
target_link_libraries(${EXECUTABLE} webthree) |
|
||||
target_link_libraries(${EXECUTABLE} ethereum) |
|
||||
target_link_libraries(${EXECUTABLE} p2p) |
|
||||
if (ETHASHCL) |
|
||||
# target_link_libraries(${EXECUTABLE} ethash-cl) |
|
||||
# target_link_libraries(${EXECUTABLE} ethash) |
|
||||
# target_link_libraries(${EXECUTABLE} OpenCL) |
|
||||
endif() |
|
||||
target_link_libraries(${EXECUTABLE} ethcore) |
|
||||
install( TARGETS ${EXECUTABLE} DESTINATION bin) |
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
@ -1,402 +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 <http://www.gnu.org/licenses/>.
|
|
||||
*/ |
|
||||
/** @file main.cpp
|
|
||||
* @author Gav Wood <i@gavwood.com> |
|
||||
* @date 2014 |
|
||||
* Ethereum client. |
|
||||
*/ |
|
||||
#if ETH_ETHASHCL |
|
||||
#define __CL_ENABLE_EXCEPTIONS |
|
||||
#define CL_USE_DEPRECATED_OPENCL_2_0_APIS |
|
||||
#if defined(__clang__) |
|
||||
#pragma clang diagnostic push |
|
||||
#pragma clang diagnostic ignored "-Wunused-parameter" |
|
||||
#include <libethash-cl/cl.hpp> |
|
||||
#pragma clang diagnostic pop |
|
||||
#else |
|
||||
#include <libethash-cl/cl.hpp> |
|
||||
#endif |
|
||||
#endif |
|
||||
#include <functional> |
|
||||
#include <boost/filesystem.hpp> |
|
||||
#include <boost/algorithm/string.hpp> |
|
||||
#if 0 |
|
||||
#include <libdevcore/TrieDB.h> |
|
||||
#include <libdevcore/TrieHash.h> |
|
||||
#include <libdevcore/RangeMask.h> |
|
||||
#include <libdevcore/Log.h> |
|
||||
#include <libdevcore/Common.h> |
|
||||
#include <libdevcore/CommonData.h> |
|
||||
#include <libdevcore/RLP.h> |
|
||||
#include <libdevcore/TransientDirectory.h> |
|
||||
#include <libdevcore/CommonIO.h> |
|
||||
#include <libdevcrypto/SecretStore.h> |
|
||||
#include <libp2p/All.h> |
|
||||
#include <libethcore/Farm.h> |
|
||||
#include <libdevcore/FileSystem.h> |
|
||||
#include <libethereum/All.h> |
|
||||
#include <libethcore/KeyManager.h> |
|
||||
#include <libethereum/AccountDiff.h> |
|
||||
#include <libethereum/DownloadMan.h> |
|
||||
#include <libethereum/Client.h> |
|
||||
#include <liblll/All.h> |
|
||||
#include <libwhisper/WhisperPeer.h> |
|
||||
#include <libwhisper/WhisperHost.h> |
|
||||
#include <test/JsonSpiritHeaders.h> |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
using namespace dev::eth; |
|
||||
using namespace dev::p2p; |
|
||||
using namespace dev::shh; |
|
||||
namespace js = json_spirit; |
|
||||
namespace fs = boost::filesystem; |
|
||||
#else |
|
||||
#include <libethcore/Sealer.h> |
|
||||
#include <libethcore/BasicAuthority.h> |
|
||||
#include <libethcore/BlockInfo.h> |
|
||||
#include <libethcore/Ethash.h> |
|
||||
#include <libethcore/Params.h> |
|
||||
#include <libethereum/All.h> |
|
||||
#include <libethereum/AccountDiff.h> |
|
||||
#include <libethereum/DownloadMan.h> |
|
||||
#include <libethereum/Client.h> |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
using namespace eth; |
|
||||
#endif |
|
||||
|
|
||||
#if 0 |
|
||||
int main() |
|
||||
{ |
|
||||
BlockInfo bi; |
|
||||
bi.difficulty = c_genesisDifficulty; |
|
||||
bi.gasLimit = c_genesisGasLimit; |
|
||||
bi.number() = 1; |
|
||||
bi.parentHash() = sha3("parentHash"); |
|
||||
|
|
||||
bytes sealedData; |
|
||||
|
|
||||
{ |
|
||||
KeyPair kp(sha3("test")); |
|
||||
SealEngineFace* se = BasicAuthority::createSealEngine(); |
|
||||
se->setOption("authority", rlp(kp.secret())); |
|
||||
se->setOption("authorities", rlpList(kp.address())); |
|
||||
cdebug << se->sealers(); |
|
||||
bool done = false; |
|
||||
se->onSealGenerated([&](SealFace const* seal){ |
|
||||
sealedData = seal->sealedHeader(bi); |
|
||||
done = true; |
|
||||
}); |
|
||||
se->generateSeal(bi); |
|
||||
while (!done) |
|
||||
this_thread::sleep_for(chrono::milliseconds(50)); |
|
||||
BasicAuthority::BlockHeader sealed = BasicAuthority::BlockHeader::fromHeader(sealedData, CheckEverything); |
|
||||
cdebug << sealed.sig(); |
|
||||
} |
|
||||
|
|
||||
{ |
|
||||
SealEngineFace* se = Ethash::createSealEngine(); |
|
||||
cdebug << se->sealers(); |
|
||||
bool done = false; |
|
||||
se->setSealer("cpu"); |
|
||||
se->onSealGenerated([&](SealFace const* seal){ |
|
||||
sealedData = seal->sealedHeader(bi); |
|
||||
done = true; |
|
||||
}); |
|
||||
se->generateSeal(bi); |
|
||||
while (!done) |
|
||||
this_thread::sleep_for(chrono::milliseconds(50)); |
|
||||
Ethash::BlockHeader sealed = Ethash::BlockHeader::fromHeader(sealedData, CheckEverything); |
|
||||
cdebug << sealed.nonce(); |
|
||||
} |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
#elif 0 |
|
||||
int main() |
|
||||
{ |
|
||||
cdebug << pbkdf2("password", asBytes("salt"), 1, 32); |
|
||||
cdebug << pbkdf2("password", asBytes("salt"), 1, 16); |
|
||||
cdebug << pbkdf2("password", asBytes("salt"), 2, 16); |
|
||||
cdebug << pbkdf2("testpassword", fromHex("de5742f1f1045c402296422cee5a8a9ecf0ac5bf594deca1170d22aef33a79cf"), 262144, 16); |
|
||||
return 0; |
|
||||
} |
|
||||
#elif 0 |
|
||||
int main() |
|
||||
{ |
|
||||
cdebug << "EXP"; |
|
||||
vector<bytes> data; |
|
||||
for (unsigned i = 0; i < 10000; ++i) |
|
||||
data.push_back(rlp(i)); |
|
||||
|
|
||||
h256 ret; |
|
||||
DEV_TIMED("triedb") |
|
||||
{ |
|
||||
MemoryDB mdb; |
|
||||
GenericTrieDB<MemoryDB> t(&mdb); |
|
||||
t.init(); |
|
||||
unsigned i = 0; |
|
||||
for (auto const& d: data) |
|
||||
t.insert(rlp(i++), d); |
|
||||
ret = t.root(); |
|
||||
} |
|
||||
cdebug << ret; |
|
||||
DEV_TIMED("hash256") |
|
||||
ret = orderedTrieRoot(data); |
|
||||
cdebug << ret; |
|
||||
} |
|
||||
#elif 0 |
|
||||
int main() |
|
||||
{ |
|
||||
KeyManager keyman; |
|
||||
if (keyman.exists()) |
|
||||
keyman.load("foo"); |
|
||||
else |
|
||||
keyman.create("foo"); |
|
||||
|
|
||||
Address a("9cab1cc4e8fe528267c6c3af664a1adbce810b5f"); |
|
||||
|
|
||||
// keyman.importExisting(fromUUID("441193ae-a767-f1c3-48ba-dd6610db5ed0"), "{\"name\":\"Gavin Wood - Main identity\"}", "bar", "{\"hint\":\"Not foo.\"}");
|
|
||||
// Address a2 = keyman.address(keyman.import(Secret::random(), "Key with no additional security."));
|
|
||||
// cdebug << toString(a2);
|
|
||||
Address a2("19c486071651b2650449ba3c6a807f316a73e8fe"); |
|
||||
|
|
||||
cdebug << keyman.accountDetails(); |
|
||||
|
|
||||
cdebug << "Secret key for " << a << "is" << keyman.secret(a, [](){ return "bar"; }); |
|
||||
cdebug << "Secret key for " << a2 << "is" << keyman.secret(a2); |
|
||||
|
|
||||
} |
|
||||
#elif 0 |
|
||||
int main() |
|
||||
{ |
|
||||
DownloadMan man; |
|
||||
DownloadSub s0(man); |
|
||||
DownloadSub s1(man); |
|
||||
DownloadSub s2(man); |
|
||||
man.resetToChain(h256s({u256(0), u256(1), u256(2), u256(3), u256(4), u256(5), u256(6), u256(7), u256(8)}), 0); |
|
||||
assert((s0.nextFetch(2) == h256Set{(u256)7, (u256)8})); |
|
||||
assert((s1.nextFetch(2) == h256Set{(u256)5, (u256)6})); |
|
||||
assert((s2.nextFetch(2) == h256Set{(u256)3, (u256)4})); |
|
||||
s0.noteBlock(u256(8)); |
|
||||
s0.doneFetch(); |
|
||||
assert((s0.nextFetch(2) == h256Set{(u256)2, (u256)7})); |
|
||||
s1.noteBlock(u256(6)); |
|
||||
s1.noteBlock(u256(5)); |
|
||||
s1.doneFetch(); |
|
||||
assert((s1.nextFetch(2) == h256Set{(u256)0, (u256)1})); |
|
||||
s0.doneFetch(); // TODO: check exact semantics of doneFetch & nextFetch. Not sure if they're right -> doneFetch calls resetFetch which kills all the info of past fetches.
|
|
||||
cdebug << s0.nextFetch(2); |
|
||||
assert((s0.nextFetch(2) == h256Set{(u256)3, (u256)4})); |
|
||||
|
|
||||
/* RangeMask<unsigned> m(0, 100);
|
|
||||
cnote << m; |
|
||||
m += UnsignedRange(3, 10); |
|
||||
cnote << m; |
|
||||
m += UnsignedRange(11, 16); |
|
||||
cnote << m; |
|
||||
m += UnsignedRange(10, 11); |
|
||||
cnote << m; |
|
||||
cnote << ~m; |
|
||||
cnote << (~m).lowest(10); |
|
||||
for (auto i: (~m).lowest(10)) |
|
||||
cnote << i;*/ |
|
||||
return 0; |
|
||||
} |
|
||||
#elif 0 |
|
||||
int main() |
|
||||
{ |
|
||||
KeyPair u = KeyPair::create(); |
|
||||
KeyPair cb = KeyPair::create(); |
|
||||
OverlayDB db; |
|
||||
State s(cb.address(), db, BaseState::Empty); |
|
||||
cnote << s.rootHash(); |
|
||||
s.addBalance(u.address(), 1 * ether); |
|
||||
Address c = s.newContract(1000 * ether, compileLLL("(suicide (caller))")); |
|
||||
s.commit(); |
|
||||
State before = s; |
|
||||
cnote << "State before transaction: " << before; |
|
||||
Transaction t(0, 10000, 10000, c, bytes(), 0, u.secret()); |
|
||||
cnote << "Transaction: " << t; |
|
||||
cnote << s.balance(c); |
|
||||
s.execute(LastHashes(), t.rlp()); |
|
||||
cnote << "State after transaction: " << s; |
|
||||
cnote << before.diff(s); |
|
||||
} |
|
||||
#elif 0 |
|
||||
int main() |
|
||||
{ |
|
||||
GenericFarm<EthashProofOfWork> f; |
|
||||
BlockInfo genesis = CanonBlockChain::genesis(); |
|
||||
genesis.difficulty = 1 << 18; |
|
||||
cdebug << genesis.boundary(); |
|
||||
|
|
||||
auto mine = [](GenericFarm<EthashProofOfWork>& f, BlockInfo const& g, unsigned timeout) { |
|
||||
BlockInfo bi = g; |
|
||||
bool completed = false; |
|
||||
f.onSolutionFound([&](EthashProofOfWork::Solution sol) |
|
||||
{ |
|
||||
bi.proof = sol; |
|
||||
return completed = true; |
|
||||
}); |
|
||||
f.setWork(bi); |
|
||||
for (unsigned i = 0; !completed && i < timeout * 10; ++i, cout << f.miningProgress() << "\r" << flush) |
|
||||
this_thread::sleep_for(chrono::milliseconds(100)); |
|
||||
cout << endl << flush; |
|
||||
cdebug << bi.mixHash << bi.nonce << (Ethash::verify(bi) ? "GOOD" : "bad"); |
|
||||
}; |
|
||||
|
|
||||
Ethash::prep(genesis); |
|
||||
|
|
||||
genesis.difficulty = u256(1) << 40; |
|
||||
genesis.noteDirty(); |
|
||||
f.startCPU(); |
|
||||
mine(f, genesis, 10); |
|
||||
|
|
||||
f.startGPU(); |
|
||||
|
|
||||
cdebug << "Good:"; |
|
||||
genesis.difficulty = 1 << 18; |
|
||||
genesis.noteDirty(); |
|
||||
mine(f, genesis, 30); |
|
||||
|
|
||||
cdebug << "Bad:"; |
|
||||
genesis.difficulty = (u256(1) << 40); |
|
||||
genesis.noteDirty(); |
|
||||
mine(f, genesis, 30); |
|
||||
|
|
||||
f.stop(); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
#elif 1 |
|
||||
int main() |
|
||||
{ |
|
||||
bytes tx = fromHex("f84c01028332dcd58004801ba024843272ee176277535489859cbd275686023fe64aabd158b6fcdf2ae6a1ab6ba02f252a5016a48e5ec8d17aefaf4324d29b9e123fa623dc5a60539b3ad3610c95"); |
|
||||
Transaction t(tx, CheckTransaction::None); |
|
||||
Public p = recover(t.signature(), t.sha3(WithoutSignature)); |
|
||||
cnote << t.signature().r; |
|
||||
cnote << t.signature().s; |
|
||||
cnote << t.signature().v; |
|
||||
cnote << p; |
|
||||
cnote << toAddress(p); |
|
||||
cnote << t.sender(); |
|
||||
} |
|
||||
#elif 0 |
|
||||
void mine(State& s, BlockChain const& _bc, SealEngineFace* _se) |
|
||||
{ |
|
||||
s.commitToSeal(_bc); |
|
||||
Notified<bytes> sealed; |
|
||||
_se->onSealGenerated([&](bytes const& sealedHeader){ sealed = sealedHeader; }); |
|
||||
_se->generateSeal(s.info()); |
|
||||
sealed.waitNot({}); |
|
||||
s.sealBlock(sealed); |
|
||||
} |
|
||||
int main() |
|
||||
{ |
|
||||
cnote << "Testing State..."; |
|
||||
|
|
||||
KeyPair me = sha3("Gav Wood"); |
|
||||
KeyPair myMiner = sha3("Gav's Miner"); |
|
||||
// KeyPair you = sha3("123");
|
|
||||
|
|
||||
Defaults::setDBPath(boost::filesystem::temp_directory_path().string() + "/" + toString(chrono::system_clock::now().time_since_epoch().count())); |
|
||||
|
|
||||
using Sealer = Ethash; |
|
||||
CanonBlockChain<Sealer> bc; |
|
||||
auto gbb = bc.headerData(bc.genesisHash()); |
|
||||
assert(Sealer::BlockHeader(bc.headerData(bc.genesisHash()), IgnoreSeal, bc.genesisHash(), HeaderData)); |
|
||||
|
|
||||
SealEngineFace* se = Sealer::createSealEngine(); |
|
||||
KeyPair kp(sha3("test")); |
|
||||
se->setOption("authority", rlp(kp.secret())); |
|
||||
se->setOption("authorities", rlpList(kp.address())); |
|
||||
|
|
||||
OverlayDB stateDB = State::openDB(bc.genesisHash()); |
|
||||
cnote << bc; |
|
||||
|
|
||||
Block s = bc.genesisBlock(stateDB); |
|
||||
s.setBeneficiary(myMiner.address()); |
|
||||
cnote << s; |
|
||||
|
|
||||
// Sync up - this won't do much until we use the last state.
|
|
||||
s.sync(bc); |
|
||||
|
|
||||
cnote << s; |
|
||||
|
|
||||
// Mine to get some ether!
|
|
||||
mine(s, bc, se); |
|
||||
|
|
||||
bytes minedBlock = s.blockData(); |
|
||||
cnote << "Mined block is" << BlockInfo(minedBlock).stateRoot(); |
|
||||
bc.import(minedBlock, stateDB); |
|
||||
|
|
||||
cnote << bc; |
|
||||
|
|
||||
s.sync(bc); |
|
||||
|
|
||||
cnote << s; |
|
||||
cnote << "Miner now has" << s.balance(myMiner.address()); |
|
||||
s.resetCurrent(); |
|
||||
cnote << "Miner now has" << s.balance(myMiner.address()); |
|
||||
|
|
||||
// Inject a transaction to transfer funds from miner to me.
|
|
||||
Transaction t(1000, 10000, 30000, me.address(), bytes(), s.transactionsFrom(myMiner.address()), myMiner.secret()); |
|
||||
assert(t.sender() == myMiner.address()); |
|
||||
s.execute(bc.lastHashes(), t); |
|
||||
|
|
||||
cnote << s; |
|
||||
|
|
||||
// Mine to get some ether and set in stone.
|
|
||||
s.commitToSeal(bc); |
|
||||
s.commitToSeal(bc); |
|
||||
mine(s, bc, se); |
|
||||
bc.attemptImport(s.blockData(), stateDB); |
|
||||
|
|
||||
cnote << bc; |
|
||||
|
|
||||
s.sync(bc); |
|
||||
|
|
||||
cnote << s; |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
#else |
|
||||
int main() |
|
||||
{ |
|
||||
string tempDir = boost::filesystem::temp_directory_path().string() + "/" + toString(chrono::system_clock::now().time_since_epoch().count()); |
|
||||
|
|
||||
KeyPair myMiner = sha3("Gav's Miner"); |
|
||||
|
|
||||
p2p::Host net("Test"); |
|
||||
cdebug << "Path:" << tempDir; |
|
||||
Client c(&net, tempDir); |
|
||||
|
|
||||
c.setBeneficiary(myMiner.address()); |
|
||||
|
|
||||
this_thread::sleep_for(chrono::milliseconds(1000)); |
|
||||
|
|
||||
c.startMining(); |
|
||||
|
|
||||
this_thread::sleep_for(chrono::milliseconds(6000)); |
|
||||
|
|
||||
c.stopMining(); |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
#endif |
|
||||
|
|
||||
@ -1 +0,0 @@ |
|||||
add_custom_target(mix) |
|
||||
@ -1,21 +0,0 @@ |
|||||
cmake_policy(SET CMP0015 NEW) |
|
||||
set(CMAKE_AUTOMOC OFF) |
|
||||
|
|
||||
aux_source_directory(. SRC_LIST) |
|
||||
|
|
||||
include_directories(BEFORE ..) |
|
||||
include_directories(${DB_INCLUDE_DIRS}) |
|
||||
|
|
||||
set(EXECUTABLE rlp) |
|
||||
|
|
||||
add_executable(${EXECUTABLE} ${SRC_LIST}) |
|
||||
|
|
||||
target_link_libraries(${EXECUTABLE} devcrypto) |
|
||||
target_link_libraries(${EXECUTABLE} ${DB_LIBRARIES}) |
|
||||
|
|
||||
if (APPLE) |
|
||||
install(TARGETS ${EXECUTABLE} DESTINATION bin) |
|
||||
else() |
|
||||
eth_install_executable(${EXECUTABLE}) |
|
||||
endif() |
|
||||
|
|
||||
@ -1,394 +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 <http://www.gnu.org/licenses/>.
|
|
||||
*/ |
|
||||
/** @file main.cpp
|
|
||||
* @author Gav Wood <i@gavwood.com> |
|
||||
* @date 2014 |
|
||||
* RLP tool. |
|
||||
*/ |
|
||||
#include <fstream> |
|
||||
#include <iostream> |
|
||||
#include <boost/algorithm/string.hpp> |
|
||||
#include "../test/JsonSpiritHeaders.h" |
|
||||
#include <libdevcore/CommonIO.h> |
|
||||
#include <libdevcore/RLP.h> |
|
||||
#include <libdevcore/SHA3.h> |
|
||||
using namespace std; |
|
||||
using namespace dev; |
|
||||
namespace js = json_spirit; |
|
||||
|
|
||||
void help() |
|
||||
{ |
|
||||
cout |
|
||||
<< "Usage rlp [OPTIONS] [ <file> | -- ]" << endl |
|
||||
<< "Options:" << endl |
|
||||
<< " -r,--render Render the given RLP. Options:" << endl |
|
||||
<< " --indent <string> Use string as the level indentation (default ' ')." << endl |
|
||||
<< " --hex-ints Render integers in hex." << endl |
|
||||
<< " --string-ints Render integers in the same way as strings." << endl |
|
||||
<< " --ascii-strings Render data as C-style strings or hex depending on content being ASCII." << endl |
|
||||
<< " --force-string Force all data to be rendered as C-style strings." << endl |
|
||||
<< " --force-escape When rendering as C-style strings, force all characters to be escaped." << endl |
|
||||
<< " --force-hex Force all data to be rendered as raw hex." << endl |
|
||||
<< " -l,--list-archive List the items in the RLP list by hash and size." << endl |
|
||||
<< " -e,--extract-archive Extract all items in the RLP list, named by hash." << endl |
|
||||
<< " -c,--create Given a simplified JSON string, output the RLP." << endl |
|
||||
<< "General options:" << endl |
|
||||
<< " -L,--lenience Try not to bomb out early if possible." << endl |
|
||||
<< " -x,--hex,--base-16 Treat input RLP as hex encoded data." << endl |
|
||||
<< " -k,--keccak Output Keccak-256 hash only." << endl |
|
||||
<< " --64,--base-64 Treat input RLP as base-64 encoded data." << endl |
|
||||
<< " -b,--bin,--base-256 Treat input RLP as raw binary data." << endl |
|
||||
<< " -h,--help Print this help message and exit." << endl |
|
||||
<< " -V,--version Show the version and exit." << endl |
|
||||
; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
void version() |
|
||||
{ |
|
||||
cout << "rlp version " << dev::Version << endl; |
|
||||
exit(0); |
|
||||
} |
|
||||
|
|
||||
enum class Mode { |
|
||||
ListArchive, |
|
||||
ExtractArchive, |
|
||||
Render, |
|
||||
Create |
|
||||
}; |
|
||||
|
|
||||
enum class Encoding { |
|
||||
Auto, |
|
||||
Hex, |
|
||||
Base64, |
|
||||
Binary, |
|
||||
Keccak, |
|
||||
}; |
|
||||
|
|
||||
bool isAscii(string const& _s) |
|
||||
{ |
|
||||
// Always hex-encode anything beginning with 0x to avoid ambiguity.
|
|
||||
if (_s.size() >= 2 && _s.substr(0, 2) == "0x") |
|
||||
return false; |
|
||||
|
|
||||
for (char c: _s) |
|
||||
if (c < 32) |
|
||||
return false; |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
class RLPStreamer |
|
||||
{ |
|
||||
public: |
|
||||
struct Prefs |
|
||||
{ |
|
||||
string indent; |
|
||||
bool hexInts = false; |
|
||||
bool stringInts = true; |
|
||||
bool hexPrefix = true; |
|
||||
bool forceString = false; |
|
||||
bool escapeAll = false; |
|
||||
bool forceHex = true; |
|
||||
}; |
|
||||
|
|
||||
RLPStreamer(ostream& _out, Prefs _p): m_out(_out), m_prefs(_p) {} |
|
||||
|
|
||||
void output(RLP const& _d, unsigned _level = 0) |
|
||||
{ |
|
||||
if (_d.isNull()) |
|
||||
m_out << "null"; |
|
||||
else if (_d.isInt() && !m_prefs.stringInts) |
|
||||
if (m_prefs.hexInts) |
|
||||
m_out << (m_prefs.hexPrefix ? "0x" : "") << toHex(toCompactBigEndian(_d.toInt<bigint>(RLP::LaissezFaire), 1), 1); |
|
||||
else |
|
||||
m_out << _d.toInt<bigint>(RLP::LaissezFaire); |
|
||||
else if (_d.isData() || (_d.isInt() && m_prefs.stringInts)) |
|
||||
if (m_prefs.forceString || (!m_prefs.forceHex && isAscii(_d.toString()))) |
|
||||
m_out << escaped(_d.toString(), m_prefs.escapeAll); |
|
||||
else |
|
||||
m_out << "\"" << (m_prefs.hexPrefix ? "0x" : "") << toHex(_d.toBytes()) << "\""; |
|
||||
else if (_d.isList()) |
|
||||
{ |
|
||||
m_out << "["; |
|
||||
string newline = "\n"; |
|
||||
for (unsigned i = 0; i < _level + 1; ++i) |
|
||||
newline += m_prefs.indent; |
|
||||
int j = 0; |
|
||||
for (auto i: _d) |
|
||||
{ |
|
||||
m_out << (j++ ? |
|
||||
(m_prefs.indent.empty() ? ", " : ("," + newline)) : |
|
||||
(m_prefs.indent.empty() ? " " : newline)); |
|
||||
output(i, _level + 1); |
|
||||
} |
|
||||
newline = newline.substr(0, newline.size() - m_prefs.indent.size()); |
|
||||
m_out << (m_prefs.indent.empty() ? (j ? " ]" : "]") : (j ? newline + "]" : "]")); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
private: |
|
||||
std::ostream& m_out; |
|
||||
Prefs m_prefs; |
|
||||
}; |
|
||||
|
|
||||
int main(int argc, char** argv) |
|
||||
{ |
|
||||
Encoding encoding = Encoding::Auto; |
|
||||
Mode mode = Mode::Render; |
|
||||
string inputFile = "--"; |
|
||||
bool lenience = false; |
|
||||
RLPStreamer::Prefs prefs; |
|
||||
|
|
||||
for (int i = 1; i < argc; ++i) |
|
||||
{ |
|
||||
string arg = argv[i]; |
|
||||
if (arg == "-h" || arg == "--help") |
|
||||
help(); |
|
||||
else if (arg == "-r" || arg == "--render") |
|
||||
mode = Mode::Render; |
|
||||
else if (arg == "-c" || arg == "--create") |
|
||||
mode = Mode::Create; |
|
||||
else if ((arg == "-i" || arg == "--indent") && argc > i) |
|
||||
prefs.indent = argv[++i]; |
|
||||
else if (arg == "--hex-ints") |
|
||||
prefs.hexInts = true; |
|
||||
else if (arg == "--string-ints") |
|
||||
prefs.stringInts = true; |
|
||||
else if (arg == "--ascii-strings") |
|
||||
prefs.forceString = prefs.forceHex = false; |
|
||||
else if (arg == "--force-string") |
|
||||
prefs.forceString = true; |
|
||||
else if (arg == "--force-hex") |
|
||||
prefs.forceHex = true, prefs.forceString = false; |
|
||||
else if (arg == "--force-escape") |
|
||||
prefs.escapeAll = true; |
|
||||
else if (arg == "-n" || arg == "--nice") |
|
||||
prefs.forceString = true, prefs.stringInts = false, prefs.forceHex = false, prefs.indent = " "; |
|
||||
else if (arg == "-l" || arg == "--list-archive") |
|
||||
mode = Mode::ListArchive; |
|
||||
else if (arg == "-e" || arg == "--extract-archive") |
|
||||
mode = Mode::ExtractArchive; |
|
||||
else if (arg == "-L" || arg == "--lenience") |
|
||||
lenience = true; |
|
||||
else if (arg == "-V" || arg == "--version") |
|
||||
version(); |
|
||||
else if (arg == "-x" || arg == "--hex" || arg == "--base-16") |
|
||||
encoding = Encoding::Hex; |
|
||||
else if (arg == "-k" || arg == "--keccak") |
|
||||
encoding = Encoding::Keccak; |
|
||||
else if (arg == "--64" || arg == "--base-64") |
|
||||
encoding = Encoding::Base64; |
|
||||
else if (arg == "-b" || arg == "--bin" || arg == "--base-256") |
|
||||
encoding = Encoding::Binary; |
|
||||
else |
|
||||
inputFile = arg; |
|
||||
} |
|
||||
|
|
||||
bytes in; |
|
||||
if (inputFile == "--") |
|
||||
for (int i = cin.get(); i != -1; i = cin.get()) |
|
||||
in.push_back((byte)i); |
|
||||
else |
|
||||
in = contents(inputFile); |
|
||||
|
|
||||
bytes b; |
|
||||
|
|
||||
if (mode != Mode::Create) |
|
||||
{ |
|
||||
if (encoding == Encoding::Auto) |
|
||||
{ |
|
||||
encoding = Encoding::Hex; |
|
||||
for (char b: in) |
|
||||
if (b != '\n' && b != ' ' && b != '\t') |
|
||||
{ |
|
||||
if (encoding == Encoding::Hex && (b < '0' || b > '9' ) && (b < 'a' || b > 'f' ) && (b < 'A' || b > 'F' )) |
|
||||
{ |
|
||||
cerr << "'" << b << "':" << (int)b << endl; |
|
||||
encoding = Encoding::Base64; |
|
||||
} |
|
||||
if (encoding == Encoding::Base64 && (b < '0' || b > '9' ) && (b < 'a' || b > 'z' ) && (b < 'A' || b > 'Z' ) && b != '+' && b != '/') |
|
||||
{ |
|
||||
encoding = Encoding::Binary; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
switch (encoding) |
|
||||
{ |
|
||||
case Encoding::Hex: |
|
||||
{ |
|
||||
string s = asString(in); |
|
||||
boost::algorithm::replace_all(s, " ", ""); |
|
||||
boost::algorithm::replace_all(s, "\n", ""); |
|
||||
boost::algorithm::replace_all(s, "\t", ""); |
|
||||
b = fromHex(s); |
|
||||
break; |
|
||||
} |
|
||||
case Encoding::Base64: |
|
||||
{ |
|
||||
string s = asString(in); |
|
||||
boost::algorithm::replace_all(s, " ", ""); |
|
||||
boost::algorithm::replace_all(s, "\n", ""); |
|
||||
boost::algorithm::replace_all(s, "\t", ""); |
|
||||
b = fromBase64(s); |
|
||||
break; |
|
||||
} |
|
||||
default: |
|
||||
swap(b, in); |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
try |
|
||||
{ |
|
||||
RLP rlp(b); |
|
||||
switch (mode) |
|
||||
{ |
|
||||
case Mode::ListArchive: |
|
||||
{ |
|
||||
if (!rlp.isList()) |
|
||||
{ |
|
||||
cout << "Error: Invalid format; RLP data is not a list." << endl; |
|
||||
exit(1); |
|
||||
} |
|
||||
cout << rlp.itemCount() << " items:" << endl; |
|
||||
for (auto i: rlp) |
|
||||
{ |
|
||||
if (!i.isData()) |
|
||||
{ |
|
||||
cout << "Error: Invalid format; RLP list item is not data." << endl; |
|
||||
if (!lenience) |
|
||||
exit(1); |
|
||||
} |
|
||||
cout << " " << i.size() << " bytes: " << sha3(i.data()) << endl; |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case Mode::ExtractArchive: |
|
||||
{ |
|
||||
if (!rlp.isList()) |
|
||||
{ |
|
||||
cout << "Error: Invalid format; RLP data is not a list." << endl; |
|
||||
exit(1); |
|
||||
} |
|
||||
cout << rlp.itemCount() << " items:" << endl; |
|
||||
for (auto i: rlp) |
|
||||
{ |
|
||||
if (!i.isData()) |
|
||||
{ |
|
||||
cout << "Error: Invalid format; RLP list item is not data." << endl; |
|
||||
if (!lenience) |
|
||||
exit(1); |
|
||||
} |
|
||||
ofstream fout; |
|
||||
fout.open(toString(sha3(i.data()))); |
|
||||
fout.write(reinterpret_cast<char const*>(i.data().data()), i.data().size()); |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case Mode::Render: |
|
||||
{ |
|
||||
RLPStreamer s(cout, prefs); |
|
||||
s.output(rlp); |
|
||||
cout << endl; |
|
||||
break; |
|
||||
} |
|
||||
case Mode::Create: |
|
||||
{ |
|
||||
vector<js::mValue> v(1); |
|
||||
try { |
|
||||
js::read_string(asString(in), v[0]); |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Error: Invalid format; bad JSON." << endl; |
|
||||
exit(1); |
|
||||
} |
|
||||
RLPStream out; |
|
||||
while (!v.empty()) |
|
||||
{ |
|
||||
auto vb = v.back(); |
|
||||
v.pop_back(); |
|
||||
switch (vb.type()) |
|
||||
{ |
|
||||
case js::array_type: |
|
||||
{ |
|
||||
js::mArray a = vb.get_array(); |
|
||||
out.appendList(a.size()); |
|
||||
for (int i = a.size() - 1; i >= 0; --i) |
|
||||
v.push_back(a[i]); |
|
||||
break; |
|
||||
} |
|
||||
case js::str_type: |
|
||||
{ |
|
||||
string const& s = vb.get_str(); |
|
||||
if (s.size() >= 2 && s.substr(0, 2) == "0x") |
|
||||
out << fromHex(s); |
|
||||
else |
|
||||
{ |
|
||||
// assume it's a normal JS escaped string.
|
|
||||
bytes ss; |
|
||||
ss.reserve(s.size()); |
|
||||
for (unsigned i = 0; i < s.size(); ++i) |
|
||||
if (s[i] == '\\' && i + 1 < s.size()) |
|
||||
{ |
|
||||
if (s[++i] == 'x' && i + 2 < s.size()) |
|
||||
ss.push_back(fromHex(s.substr(i, 2))[0]); |
|
||||
} |
|
||||
else if (s[i] != '\\') |
|
||||
ss.push_back((byte)s[i]); |
|
||||
out << ss; |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
case js::int_type: |
|
||||
out << vb.get_int(); |
|
||||
break; |
|
||||
default: |
|
||||
cerr << "ERROR: Unsupported type in JSON." << endl; |
|
||||
if (!lenience) |
|
||||
exit(1); |
|
||||
} |
|
||||
} |
|
||||
switch (encoding) |
|
||||
{ |
|
||||
case Encoding::Hex: case Encoding::Auto: |
|
||||
cout << toHex(out.out()) << endl; |
|
||||
break; |
|
||||
case Encoding::Base64: |
|
||||
cout << toBase64(&out.out()) << endl; |
|
||||
break; |
|
||||
case Encoding::Binary: |
|
||||
cout.write((char const*)out.out().data(), out.out().size()); |
|
||||
break; |
|
||||
case Encoding::Keccak: |
|
||||
cout << sha3(out.out()).hex() << endl; |
|
||||
break; |
|
||||
} |
|
||||
break; |
|
||||
} |
|
||||
default:; |
|
||||
} |
|
||||
} |
|
||||
catch (...) |
|
||||
{ |
|
||||
cerr << "Error: Invalid format; bad RLP." << endl; |
|
||||
exit(1); |
|
||||
} |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
Loading…
Reference in new issue