Gav Wood
10 years ago
20 changed files with 956 additions and 411 deletions
@ -0,0 +1,326 @@ |
|||
/*
|
|||
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 KnownState.cpp |
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2015 |
|||
* Contains knowledge about the state of the virtual machine at a specific instruction. |
|||
*/ |
|||
|
|||
#include "KnownState.h" |
|||
#include <functional> |
|||
#include <libdevcrypto/SHA3.h> |
|||
#include <libevmasm/AssemblyItem.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
ostream& KnownState::stream(ostream& _out) const |
|||
{ |
|||
auto streamExpressionClass = [this](ostream& _out, Id _id) |
|||
{ |
|||
auto const& expr = m_expressionClasses->representative(_id); |
|||
_out << " " << dec << _id << ": "; |
|||
if (!expr.item) |
|||
_out << " no item"; |
|||
else if (expr.item->type() == UndefinedItem) |
|||
_out << " unknown " << int(expr.item->data()); |
|||
else |
|||
_out << *expr.item; |
|||
if (expr.sequenceNumber) |
|||
_out << "@" << dec << expr.sequenceNumber; |
|||
_out << "("; |
|||
for (Id arg: expr.arguments) |
|||
_out << dec << arg << ","; |
|||
_out << ")" << endl; |
|||
}; |
|||
|
|||
_out << "=== State ===" << endl; |
|||
_out << "Stack height: " << dec << m_stackHeight << endl; |
|||
_out << "Equivalence classes: " << endl; |
|||
for (Id eqClass = 0; eqClass < m_expressionClasses->size(); ++eqClass) |
|||
streamExpressionClass(_out, eqClass); |
|||
|
|||
_out << "Stack: " << endl; |
|||
for (auto const& it: m_stackElements) |
|||
{ |
|||
_out << " " << dec << it.first << ": "; |
|||
streamExpressionClass(_out, it.second); |
|||
} |
|||
_out << "Storage: " << endl; |
|||
for (auto const& it: m_storageContent) |
|||
{ |
|||
_out << " "; |
|||
streamExpressionClass(_out, it.first); |
|||
_out << ": "; |
|||
streamExpressionClass(_out, it.second); |
|||
} |
|||
_out << "Memory: " << endl; |
|||
for (auto const& it: m_memoryContent) |
|||
{ |
|||
_out << " "; |
|||
streamExpressionClass(_out, it.first); |
|||
_out << ": "; |
|||
streamExpressionClass(_out, it.second); |
|||
} |
|||
|
|||
return _out; |
|||
} |
|||
|
|||
KnownState::StoreOperation KnownState::feedItem(AssemblyItem const& _item, bool _copyItem) |
|||
{ |
|||
StoreOperation op; |
|||
if (_item.type() == Tag) |
|||
{ |
|||
// can be ignored
|
|||
} |
|||
else if (_item.type() != Operation) |
|||
{ |
|||
assertThrow(_item.deposit() == 1, InvalidDeposit, ""); |
|||
setStackElement(++m_stackHeight, m_expressionClasses->find(_item, {}, _copyItem)); |
|||
} |
|||
else |
|||
{ |
|||
Instruction instruction = _item.instruction(); |
|||
InstructionInfo info = instructionInfo(instruction); |
|||
if (SemanticInformation::isDupInstruction(_item)) |
|||
setStackElement( |
|||
m_stackHeight + 1, |
|||
stackElement( |
|||
m_stackHeight - int(instruction) + int(Instruction::DUP1), |
|||
_item.getLocation() |
|||
) |
|||
); |
|||
else if (SemanticInformation::isSwapInstruction(_item)) |
|||
swapStackElements( |
|||
m_stackHeight, |
|||
m_stackHeight - 1 - int(instruction) + int(Instruction::SWAP1), |
|||
_item.getLocation() |
|||
); |
|||
else if (instruction != Instruction::POP) |
|||
{ |
|||
vector<Id> arguments(info.args); |
|||
for (int i = 0; i < info.args; ++i) |
|||
arguments[i] = stackElement(m_stackHeight - i, _item.getLocation()); |
|||
|
|||
if (_item.instruction() == Instruction::SSTORE) |
|||
op = storeInStorage(arguments[0], arguments[1], _item.getLocation()); |
|||
else if (_item.instruction() == Instruction::SLOAD) |
|||
setStackElement( |
|||
m_stackHeight + _item.deposit(), |
|||
loadFromStorage(arguments[0], _item.getLocation()) |
|||
); |
|||
else if (_item.instruction() == Instruction::MSTORE) |
|||
op = storeInMemory(arguments[0], arguments[1], _item.getLocation()); |
|||
else if (_item.instruction() == Instruction::MLOAD) |
|||
setStackElement( |
|||
m_stackHeight + _item.deposit(), |
|||
loadFromMemory(arguments[0], _item.getLocation()) |
|||
); |
|||
else if (_item.instruction() == Instruction::SHA3) |
|||
setStackElement( |
|||
m_stackHeight + _item.deposit(), |
|||
applySha3(arguments.at(0), arguments.at(1), _item.getLocation()) |
|||
); |
|||
else |
|||
{ |
|||
if (SemanticInformation::invalidatesMemory(_item.instruction())) |
|||
resetMemory(); |
|||
if (SemanticInformation::invalidatesStorage(_item.instruction())) |
|||
resetStorage(); |
|||
assertThrow(info.ret <= 1, InvalidDeposit, ""); |
|||
if (info.ret == 1) |
|||
setStackElement( |
|||
m_stackHeight + _item.deposit(), |
|||
m_expressionClasses->find(_item, arguments, _copyItem) |
|||
); |
|||
} |
|||
} |
|||
m_stackElements.erase( |
|||
m_stackElements.upper_bound(m_stackHeight + _item.deposit()), |
|||
m_stackElements.end() |
|||
); |
|||
m_stackHeight += _item.deposit(); |
|||
} |
|||
return op; |
|||
} |
|||
|
|||
void KnownState::reduceToCommonKnowledge(KnownState const& /*_other*/) |
|||
{ |
|||
//@todo
|
|||
*this = KnownState(m_expressionClasses); |
|||
} |
|||
|
|||
bool KnownState::operator==(const KnownState& _other) const |
|||
{ |
|||
//@todo
|
|||
return ( |
|||
m_stackElements.empty() && |
|||
_other.m_stackElements.empty() && |
|||
m_storageContent.empty() && |
|||
_other.m_storageContent.empty() && |
|||
m_memoryContent.empty() && |
|||
_other.m_memoryContent.empty() |
|||
); |
|||
} |
|||
|
|||
ExpressionClasses::Id KnownState::stackElement(int _stackHeight, SourceLocation const& _location) |
|||
{ |
|||
if (m_stackElements.count(_stackHeight)) |
|||
return m_stackElements.at(_stackHeight); |
|||
// Stack element not found (not assigned yet), create new unknown equivalence class.
|
|||
//@todo check that we do not infer incorrect equivalences when the stack is cleared partially
|
|||
//in between.
|
|||
return m_stackElements[_stackHeight] = initialStackElement(_stackHeight, _location); |
|||
} |
|||
|
|||
ExpressionClasses::Id KnownState::initialStackElement( |
|||
int _stackHeight, |
|||
SourceLocation const& _location |
|||
) |
|||
{ |
|||
// This is a special assembly item that refers to elements pre-existing on the initial stack.
|
|||
return m_expressionClasses->find(AssemblyItem(UndefinedItem, u256(_stackHeight), _location)); |
|||
} |
|||
|
|||
void KnownState::setStackElement(int _stackHeight, Id _class) |
|||
{ |
|||
m_stackElements[_stackHeight] = _class; |
|||
} |
|||
|
|||
void KnownState::swapStackElements( |
|||
int _stackHeightA, |
|||
int _stackHeightB, |
|||
SourceLocation const& _location |
|||
) |
|||
{ |
|||
assertThrow(_stackHeightA != _stackHeightB, OptimizerException, "Swap on same stack elements."); |
|||
// ensure they are created
|
|||
stackElement(_stackHeightA, _location); |
|||
stackElement(_stackHeightB, _location); |
|||
|
|||
swap(m_stackElements[_stackHeightA], m_stackElements[_stackHeightB]); |
|||
} |
|||
|
|||
KnownState::StoreOperation KnownState::storeInStorage( |
|||
Id _slot, |
|||
Id _value, |
|||
SourceLocation const& _location) |
|||
{ |
|||
if (m_storageContent.count(_slot) && m_storageContent[_slot] == _value) |
|||
// do not execute the storage if we know that the value is already there
|
|||
return StoreOperation(); |
|||
m_sequenceNumber++; |
|||
decltype(m_storageContent) storageContents; |
|||
// Copy over all values (i.e. retain knowledge about them) where we know that this store
|
|||
// operation will not destroy the knowledge. Specifically, we copy storage locations we know
|
|||
// are different from _slot or locations where we know that the stored value is equal to _value.
|
|||
for (auto const& storageItem: m_storageContent) |
|||
if (m_expressionClasses->knownToBeDifferent(storageItem.first, _slot) || storageItem.second == _value) |
|||
storageContents.insert(storageItem); |
|||
m_storageContent = move(storageContents); |
|||
|
|||
AssemblyItem item(Instruction::SSTORE, _location); |
|||
Id id = m_expressionClasses->find(item, {_slot, _value}, true, m_sequenceNumber); |
|||
StoreOperation operation(StoreOperation::Storage, _slot, m_sequenceNumber, id); |
|||
m_storageContent[_slot] = _value; |
|||
// increment a second time so that we get unique sequence numbers for writes
|
|||
m_sequenceNumber++; |
|||
|
|||
return operation; |
|||
} |
|||
|
|||
ExpressionClasses::Id KnownState::loadFromStorage(Id _slot, SourceLocation const& _location) |
|||
{ |
|||
if (m_storageContent.count(_slot)) |
|||
return m_storageContent.at(_slot); |
|||
|
|||
AssemblyItem item(Instruction::SLOAD, _location); |
|||
return m_storageContent[_slot] = m_expressionClasses->find(item, {_slot}, true, m_sequenceNumber); |
|||
} |
|||
|
|||
KnownState::StoreOperation KnownState::storeInMemory(Id _slot, Id _value, SourceLocation const& _location) |
|||
{ |
|||
if (m_memoryContent.count(_slot) && m_memoryContent[_slot] == _value) |
|||
// do not execute the store if we know that the value is already there
|
|||
return StoreOperation(); |
|||
m_sequenceNumber++; |
|||
decltype(m_memoryContent) memoryContents; |
|||
// copy over values at points where we know that they are different from _slot by at least 32
|
|||
for (auto const& memoryItem: m_memoryContent) |
|||
if (m_expressionClasses->knownToBeDifferentBy32(memoryItem.first, _slot)) |
|||
memoryContents.insert(memoryItem); |
|||
m_memoryContent = move(memoryContents); |
|||
|
|||
AssemblyItem item(Instruction::MSTORE, _location); |
|||
Id id = m_expressionClasses->find(item, {_slot, _value}, true, m_sequenceNumber); |
|||
StoreOperation operation(StoreOperation(StoreOperation::Memory, _slot, m_sequenceNumber, id)); |
|||
m_memoryContent[_slot] = _value; |
|||
// increment a second time so that we get unique sequence numbers for writes
|
|||
m_sequenceNumber++; |
|||
return operation; |
|||
} |
|||
|
|||
ExpressionClasses::Id KnownState::loadFromMemory(Id _slot, SourceLocation const& _location) |
|||
{ |
|||
if (m_memoryContent.count(_slot)) |
|||
return m_memoryContent.at(_slot); |
|||
|
|||
AssemblyItem item(Instruction::MLOAD, _location); |
|||
return m_memoryContent[_slot] = m_expressionClasses->find(item, {_slot}, true, m_sequenceNumber); |
|||
} |
|||
|
|||
KnownState::Id KnownState::applySha3( |
|||
Id _start, |
|||
Id _length, |
|||
SourceLocation const& _location |
|||
) |
|||
{ |
|||
AssemblyItem sha3Item(Instruction::SHA3, _location); |
|||
// Special logic if length is a short constant, otherwise we cannot tell.
|
|||
u256 const* l = m_expressionClasses->knownConstant(_length); |
|||
// unknown or too large length
|
|||
if (!l || *l > 128) |
|||
return m_expressionClasses->find(sha3Item, {_start, _length}, true, m_sequenceNumber); |
|||
|
|||
vector<Id> arguments; |
|||
for (u256 i = 0; i < *l; i += 32) |
|||
{ |
|||
Id slot = m_expressionClasses->find( |
|||
AssemblyItem(Instruction::ADD, _location), |
|||
{_start, m_expressionClasses->find(i)} |
|||
); |
|||
arguments.push_back(loadFromMemory(slot, _location)); |
|||
} |
|||
if (m_knownSha3Hashes.count(arguments)) |
|||
return m_knownSha3Hashes.at(arguments); |
|||
Id v; |
|||
// If all arguments are known constants, compute the sha3 here
|
|||
if (all_of(arguments.begin(), arguments.end(), [this](Id _a) { return !!m_expressionClasses->knownConstant(_a); })) |
|||
{ |
|||
bytes data; |
|||
for (Id a: arguments) |
|||
data += toBigEndian(*m_expressionClasses->knownConstant(a)); |
|||
data.resize(size_t(*l)); |
|||
v = m_expressionClasses->find(AssemblyItem(u256(sha3(data)), _location)); |
|||
} |
|||
else |
|||
v = m_expressionClasses->find(sha3Item, {_start, _length}, true, m_sequenceNumber); |
|||
return m_knownSha3Hashes[arguments] = v; |
|||
} |
|||
|
|||
@ -0,0 +1,163 @@ |
|||
/*
|
|||
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 KnownState.h |
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2015 |
|||
* Contains knowledge about the state of the virtual machine at a specific instruction. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <vector> |
|||
#include <map> |
|||
#include <set> |
|||
#include <tuple> |
|||
#include <memory> |
|||
#include <ostream> |
|||
#include <libdevcore/CommonIO.h> |
|||
#include <libdevcore/Exceptions.h> |
|||
#include <libevmasm/ExpressionClasses.h> |
|||
#include <libevmasm/SemanticInformation.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
class AssemblyItem; |
|||
using AssemblyItems = std::vector<AssemblyItem>; |
|||
|
|||
/**
|
|||
* Class to infer and store knowledge about the state of the virtual machine at a specific |
|||
* instruction. |
|||
* |
|||
* The general workings are that for each assembly item that is fed, an equivalence class is |
|||
* derived from the operation and the equivalence class of its arguments. DUPi, SWAPi and some |
|||
* arithmetic instructions are used to infer equivalences while these classes are determined. |
|||
*/ |
|||
class KnownState |
|||
{ |
|||
public: |
|||
using Id = ExpressionClasses::Id; |
|||
struct StoreOperation |
|||
{ |
|||
enum Target { Invalid, Memory, Storage }; |
|||
StoreOperation(): target(Invalid), sequenceNumber(-1) {} |
|||
StoreOperation( |
|||
Target _target, |
|||
Id _slot, |
|||
unsigned _sequenceNumber, |
|||
Id _expression |
|||
): target(_target), slot(_slot), sequenceNumber(_sequenceNumber), expression(_expression) {} |
|||
bool isValid() const { return target != Invalid; } |
|||
Target target; |
|||
Id slot; |
|||
unsigned sequenceNumber; |
|||
Id expression; |
|||
}; |
|||
|
|||
explicit KnownState( |
|||
std::shared_ptr<ExpressionClasses> _expressionClasses = std::make_shared<ExpressionClasses>() |
|||
): m_expressionClasses(_expressionClasses) |
|||
{ |
|||
} |
|||
|
|||
/// Streams debugging information to @a _out.
|
|||
std::ostream& stream(std::ostream& _out) const; |
|||
|
|||
/// Feeds the item into the system for analysis.
|
|||
/// @returns a possible store operation
|
|||
StoreOperation feedItem(AssemblyItem const& _item, bool _copyItem = false); |
|||
|
|||
/// Resets any knowledge about storage.
|
|||
void resetStorage() { m_storageContent.clear(); } |
|||
/// Resets any knowledge about storage.
|
|||
void resetMemory() { m_memoryContent.clear(); } |
|||
/// Resets any knowledge about the current stack.
|
|||
void resetStack() { m_stackElements.clear(); m_stackHeight = 0; } |
|||
/// Resets any knowledge.
|
|||
void reset() { resetStorage(); resetMemory(); resetStack(); } |
|||
|
|||
/// Manually increments the storage and memory sequence number.
|
|||
void incrementSequenceNumber() { m_sequenceNumber += 2; } |
|||
|
|||
/// Replaces the state by the intersection with _other, i.e. only equal knowledge is retained.
|
|||
/// If the stack heighht is different, the smaller one is used and the stack is compared
|
|||
/// relatively.
|
|||
void reduceToCommonKnowledge(KnownState const& _other); |
|||
|
|||
/// @returns a shared pointer to a copy of this state.
|
|||
std::shared_ptr<KnownState> copy() const { return std::make_shared<KnownState>(*this); } |
|||
|
|||
/// @returns true if the knowledge about the state of both objects is (known to be) equal.
|
|||
bool operator==(KnownState const& _other) const; |
|||
|
|||
///@todo the sequence numbers in two copies of this class should never be the same.
|
|||
/// might be doable using two-dimensional sequence numbers, where the first value is incremented
|
|||
/// for each copy
|
|||
|
|||
/// Retrieves the current equivalence class fo the given stack element (or generates a new
|
|||
/// one if it does not exist yet).
|
|||
Id stackElement(int _stackHeight, SourceLocation const& _location); |
|||
/// @returns the equivalence class id of the special initial stack element at the given height.
|
|||
Id initialStackElement(int _stackHeight, SourceLocation const& _location); |
|||
|
|||
int stackHeight() const { return m_stackHeight; } |
|||
std::map<int, Id> const& stackElements() const { return m_stackElements; } |
|||
ExpressionClasses& expressionClasses() const { return *m_expressionClasses; } |
|||
|
|||
private: |
|||
/// Assigns a new equivalence class to the next sequence number of the given stack element.
|
|||
void setStackElement(int _stackHeight, Id _class); |
|||
/// Swaps the given stack elements in their next sequence number.
|
|||
void swapStackElements(int _stackHeightA, int _stackHeightB, SourceLocation const& _location); |
|||
|
|||
/// Increments the sequence number, deletes all storage information that might be overwritten
|
|||
/// and stores the new value at the given slot.
|
|||
/// @returns the store operation, which might be invalid if storage was not modified
|
|||
StoreOperation storeInStorage(Id _slot, Id _value, SourceLocation const& _location); |
|||
/// Retrieves the current value at the given slot in storage or creates a new special sload class.
|
|||
Id loadFromStorage(Id _slot, SourceLocation const& _location); |
|||
/// Increments the sequence number, deletes all memory information that might be overwritten
|
|||
/// and stores the new value at the given slot.
|
|||
/// @returns the store operation, which might be invalid if memory was not modified
|
|||
StoreOperation storeInMemory(Id _slot, Id _value, SourceLocation const& _location); |
|||
/// Retrieves the current value at the given slot in memory or creates a new special mload class.
|
|||
Id loadFromMemory(Id _slot, SourceLocation const& _location); |
|||
/// Finds or creates a new expression that applies the sha3 hash function to the contents in memory.
|
|||
Id applySha3(Id _start, Id _length, SourceLocation const& _location); |
|||
|
|||
/// Current stack height, can be negative.
|
|||
int m_stackHeight = 0; |
|||
/// Current stack layout, mapping stack height -> equivalence class
|
|||
std::map<int, Id> m_stackElements; |
|||
/// Current sequence number, this is incremented with each modification to storage or memory.
|
|||
unsigned m_sequenceNumber = 1; |
|||
/// Knowledge about storage content.
|
|||
std::map<Id, Id> m_storageContent; |
|||
/// Knowledge about memory content. Keys are memory addresses, note that the values overlap
|
|||
/// and are not contained here if they are not completely known.
|
|||
std::map<Id, Id> m_memoryContent; |
|||
/// Keeps record of all sha3 hashes that are computed.
|
|||
std::map<std::vector<Id>, Id> m_knownSha3Hashes; |
|||
/// Structure containing the classes of equivalent expressions.
|
|||
std::shared_ptr<ExpressionClasses> m_expressionClasses; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
Loading…
Reference in new issue