aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Changelog.md1
-rw-r--r--docs/miscellaneous.rst5
-rw-r--r--docs/security-considerations.rst3
-rw-r--r--docs/solidity-by-example.rst17
-rw-r--r--docs/types.rst10
-rw-r--r--docs/units-and-global-variables.rst15
-rw-r--r--libdevcore/CommonData.h6
-rw-r--r--libsolidity/ast/AST.cpp26
-rw-r--r--libsolidity/ast/AST.h6
-rw-r--r--libsolidity/codegen/CompilerContext.cpp1
-rw-r--r--libsolidity/codegen/ExpressionCompiler.cpp7
-rw-r--r--libsolidity/interface/CompilerStack.cpp29
-rw-r--r--libsolidity/interface/CompilerStack.h74
-rw-r--r--libsolidity/interface/StandardCompiler.cpp41
-rw-r--r--test/libevmasm/Optimiser.cpp871
-rw-r--r--test/libsolidity/Metadata.cpp69
-rw-r--r--test/libsolidity/SolidityOptimizer.cpp823
17 files changed, 1102 insertions, 902 deletions
diff --git a/Changelog.md b/Changelog.md
index 8a475e4d..e765b583 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -4,6 +4,7 @@ Features:
* C API (``jsonCompiler``): Export the ``license`` method.
* Inline Assembly: Show useful error message if trying to access calldata variables.
* Inline Assembly: Support variable declaration without initial value (defaults to 0).
+ * Metadata: Only include files which were used to compile the given contract.
* Type Checker: Disallow value transfers to contracts without a payable fallback function.
* Type Checker: Include types in explicit conversion error message.
* Type Checker: Raise proper error for arrays too large for ABI encoding.
diff --git a/docs/miscellaneous.rst b/docs/miscellaneous.rst
index 1fcdb2fc..e364bee7 100644
--- a/docs/miscellaneous.rst
+++ b/docs/miscellaneous.rst
@@ -469,7 +469,7 @@ Global Variables
- ``require(bool condition)``: abort execution and revert state changes if condition is ``false`` (use for malformed input or error in external component)
- ``revert()``: abort execution and revert state changes
- ``keccak256(...) returns (bytes32)``: compute the Ethereum-SHA-3 (Keccak-256) hash of the (tightly packed) arguments
-- ``sha3(...) returns (bytes32)``: an alias to `keccak256()`
+- ``sha3(...) returns (bytes32)``: an alias to `keccak256`
- ``sha256(...) returns (bytes32)``: compute the SHA-256 hash of the (tightly packed) arguments
- ``ripemd160(...) returns (bytes20)``: compute the RIPEMD-160 hash of the (tightly packed) arguments
- ``ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) returns (address)``: recover address associated with the public key from elliptic curve signature, return zero on error
@@ -478,6 +478,7 @@ Global Variables
- ``this`` (current contract's type): the current contract, explicitly convertible to ``address``
- ``super``: the contract one level higher in the inheritance hierarchy
- ``selfdestruct(address recipient)``: destroy the current contract, sending its funds to the given address
+- ``suicide(address recipieint)``: an alias to `selfdestruct``
- ``<address>.balance`` (``uint256``): balance of the :ref:`address` in Wei
- ``<address>.send(uint256 amount) returns (bool)``: send given amount of Wei to :ref:`address`, returns ``false`` on failure
- ``<address>.transfer(uint256 amount)``: send given amount of Wei to :ref:`address`, throws on failure
@@ -515,7 +516,7 @@ Reserved Keywords
These keywords are reserved in Solidity. They might become part of the syntax in the future:
-``abstract``, ``after``, ``case``, ``catch``, ``default``, ``final``, ``in``, ``inline``, ``interface``, ``let``, ``match``, ``null``,
+``abstract``, ``after``, ``case``, ``catch``, ``default``, ``final``, ``in``, ``inline``, ``let``, ``match``, ``null``,
``of``, ``pure``, ``relocatable``, ``static``, ``switch``, ``try``, ``type``, ``typeof``, ``view``.
Language Grammar
diff --git a/docs/security-considerations.rst b/docs/security-considerations.rst
index 9efc5721..6586cb5f 100644
--- a/docs/security-considerations.rst
+++ b/docs/security-considerations.rst
@@ -280,8 +280,7 @@ Formal Verification
Using formal verification, it is possible to perform an automated mathematical
proof that your source code fulfills a certain formal specification.
The specification is still formal (just as the source code), but usually much
-simpler. There is a prototype in Solidity that performs formal verification and
-it will be better documented soon.
+simpler.
Note that formal verification itself can only help you understand the
difference between what you did (the specification) and how you did it
diff --git a/docs/solidity-by-example.rst b/docs/solidity-by-example.rst
index e1fd4914..71d27192 100644
--- a/docs/solidity-by-example.rst
+++ b/docs/solidity-by-example.rst
@@ -101,7 +101,7 @@ of votes.
/// Delegate your vote to the voter `to`.
function delegate(address to) {
// assigns reference
- Voter sender = voters[msg.sender];
+ Voter storage sender = voters[msg.sender];
require(!sender.voted);
// Self-delegation is not allowed.
@@ -141,7 +141,7 @@ of votes.
/// Give your vote (including votes delegated to you)
/// to proposal `proposals[proposal].name`.
function vote(uint proposal) {
- Voter sender = voters[msg.sender];
+ Voter storage sender = voters[msg.sender];
require(!sender.voted);
sender.voted = true;
sender.vote = proposal;
@@ -289,7 +289,7 @@ activate themselves.
/// Withdraw a bid that was overbid.
function withdraw() returns (bool) {
- var amount = pendingReturns[msg.sender];
+ uint amount = pendingReturns[msg.sender];
if (amount > 0) {
// It is important to set this to zero because the recipient
// can call this function again as part of the receiving call
@@ -491,8 +491,8 @@ high or low invalid bids.
}
/// Withdraw a bid that was overbid.
- function withdraw() returns (bool) {
- var amount = pendingReturns[msg.sender];
+ function withdraw() {
+ uint amount = pendingReturns[msg.sender];
if (amount > 0) {
// It is important to set this to zero because the recipient
// can call this function again as part of the receiving call
@@ -500,13 +500,8 @@ high or low invalid bids.
// conditions -> effects -> interaction).
pendingReturns[msg.sender] = 0;
- if (!msg.sender.send(amount)){
- // No need to call throw here, just reset the amount owing
- pendingReturns[msg.sender] = amount;
- return false;
- }
+ msg.sender.transfer(amount);
}
- return true;
}
/// End the auction and send the highest bid
diff --git a/docs/types.rst b/docs/types.rst
index b963c5b7..dd9c6269 100644
--- a/docs/types.rst
+++ b/docs/types.rst
@@ -135,6 +135,9 @@ The ``.gas()`` option is available on all three methods, while the ``.value()``
All contracts inherit the members of address, so it is possible to query the balance of the
current contract using ``this.balance``.
+.. note::
+ The use of ``callcode`` is discouraged and will be removed in the future.
+
.. warning::
All these functions are low-level functions and should be used with care.
Specifically, any unknown contract might be malicious and if you call it, you
@@ -436,7 +439,8 @@ Another example that uses external function types::
}
}
-Note that lambda or inline functions are planned but not yet supported.
+.. note::
+ Lambda or inline functions are planned but not yet supported.
.. index:: ! type;reference, ! reference type, storage, memory, location, array, struct
@@ -739,7 +743,7 @@ shown in the following example:
}
function contribute(uint campaignID) payable {
- Campaign c = campaigns[campaignID];
+ Campaign storage c = campaigns[campaignID];
// Creates a new temporary memory struct, initialised with the given values
// and copies it over to storage.
// Note that you can also use Funder(msg.sender, msg.value) to initialise.
@@ -748,7 +752,7 @@ shown in the following example:
}
function checkGoalReached(uint campaignID) returns (bool reached) {
- Campaign c = campaigns[campaignID];
+ Campaign storage c = campaigns[campaignID];
if (c.amount < c.fundingGoal)
return false;
uint amount = c.amount;
diff --git a/docs/units-and-global-variables.rst b/docs/units-and-global-variables.rst
index 7d21f065..64795306 100644
--- a/docs/units-and-global-variables.rst
+++ b/docs/units-and-global-variables.rst
@@ -35,7 +35,9 @@ These suffixes cannot be applied to variables. If you want to
interpret some input variable in e.g. days, you can do it in the following way::
function f(uint start, uint daysAfter) {
- if (now >= start + daysAfter * 1 days) { ... }
+ if (now >= start + daysAfter * 1 days) {
+ // ...
+ }
}
Special Variables and Functions
@@ -70,6 +72,7 @@ Block and Transaction Properties
``msg.value`` can change for every **external** function call.
This includes calls to library functions.
+.. note::
If you want to implement access restrictions in library functions using
``msg.sender``, you have to manually supply the value of
``msg.sender`` as an argument.
@@ -102,10 +105,10 @@ Mathematical and Cryptographic Functions
compute ``(x * y) % k`` where the multiplication is performed with arbitrary precision and does not wrap around at ``2**256``.
``keccak256(...) returns (bytes32)``:
compute the Ethereum-SHA-3 (Keccak-256) hash of the (tightly packed) arguments
-``sha3(...) returns (bytes32)``:
- alias to ``keccak256()``
``sha256(...) returns (bytes32)``:
compute the SHA-256 hash of the (tightly packed) arguments
+``sha3(...) returns (bytes32)``:
+ alias to ``keccak256``
``ripemd160(...) returns (bytes20)``:
compute RIPEMD-160 hash of the (tightly packed) arguments
``ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) returns (address)``:
@@ -157,6 +160,9 @@ For more information, see the section on :ref:`address`.
to make safe Ether transfers, always check the return value of ``send``, use ``transfer`` or even better:
Use a pattern where the recipient withdraws the money.
+.. note::
+ The use of ``callcode`` is discouraged and will be removed in the future.
+
.. index:: this, selfdestruct
Contract Related
@@ -168,5 +174,8 @@ Contract Related
``selfdestruct(address recipient)``:
destroy the current contract, sending its funds to the given :ref:`address`
+``suicide(address recipient)``:
+ alias to ``selfdestruct``
+
Furthermore, all functions of the current contract are callable directly including the current function.
diff --git a/libdevcore/CommonData.h b/libdevcore/CommonData.h
index 4297f606..ab4bfe68 100644
--- a/libdevcore/CommonData.h
+++ b/libdevcore/CommonData.h
@@ -166,6 +166,12 @@ template <class T, class U> std::vector<T>& operator+=(std::vector<T>& _a, U con
_a.push_back(i);
return _a;
}
+/// Concatenate the contents of a container onto a set
+template <class T, class U> std::set<T>& operator+=(std::set<T>& _a, U const& _b)
+{
+ _a.insert(_b.begin(), _b.end());
+ return _a;
+}
/// Concatenate two vectors of elements.
template <class T>
inline std::vector<T> operator+(std::vector<T> const& _a, std::vector<T> const& _b)
diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 724a908f..ebc8bd48 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -84,13 +84,35 @@ SourceUnitAnnotation& SourceUnit::annotation() const
return dynamic_cast<SourceUnitAnnotation&>(*m_annotation);
}
-string Declaration::sourceUnitName() const
+set<SourceUnit const*> SourceUnit::referencedSourceUnits(bool _recurse, set<SourceUnit const*> _skipList) const
+{
+ set<SourceUnit const*> sourceUnits;
+ for (ImportDirective const* importDirective: filteredNodes<ImportDirective>(nodes()))
+ {
+ auto const& sourceUnit = importDirective->annotation().sourceUnit;
+ if (!_skipList.count(sourceUnit))
+ {
+ _skipList.insert(sourceUnit);
+ sourceUnits.insert(sourceUnit);
+ if (_recurse)
+ sourceUnits += sourceUnit->referencedSourceUnits(true, _skipList);
+ }
+ }
+ return sourceUnits;
+}
+
+SourceUnit const& Declaration::sourceUnit() const
{
solAssert(!!m_scope, "");
ASTNode const* scope = m_scope;
while (dynamic_cast<Declaration const*>(scope) && dynamic_cast<Declaration const*>(scope)->m_scope)
scope = dynamic_cast<Declaration const*>(scope)->m_scope;
- return dynamic_cast<SourceUnit const&>(*scope).annotation().path;
+ return dynamic_cast<SourceUnit const&>(*scope);
+}
+
+string Declaration::sourceUnitName() const
+{
+ return sourceUnit().annotation().path;
}
ImportAnnotation& ImportDirective::annotation() const
diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index 81ddc754..8012bcb4 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -136,6 +136,9 @@ public:
std::vector<ASTPointer<ASTNode>> nodes() const { return m_nodes; }
+ /// @returns a set of referenced SourceUnits. Recursively if @a _recurse is true.
+ std::set<SourceUnit const*> referencedSourceUnits(bool _recurse = false, std::set<SourceUnit const*> _skipList = std::set<SourceUnit const*>()) const;
+
private:
std::vector<ASTPointer<ASTNode>> m_nodes;
};
@@ -168,6 +171,9 @@ public:
ASTNode const* scope() const { return m_scope; }
void setScope(ASTNode const* _scope) { m_scope = _scope; }
+ /// @returns the source unit this declaration is present in.
+ SourceUnit const& sourceUnit() const;
+
/// @returns the source name this declaration is present in.
/// Can be combined with annotation().canonicalName to form a globally unique name.
std::string sourceUnitName() const;
diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 6875bda1..9aaf5844 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -310,6 +310,7 @@ void CompilerContext::appendInlineAssembly(
if (stackDiff < 1 || stackDiff > 16)
BOOST_THROW_EXCEPTION(
CompilerError() <<
+ errinfo_sourceLocation(_identifier.location) <<
errinfo_comment("Stack too deep (" + to_string(stackDiff) + "), try removing local variables.")
);
if (_context == julia::IdentifierContext::RValue)
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 82518e8c..8a28b454 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -174,7 +174,12 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
retSizeOnStack = returnTypes.front()->sizeOnStack();
}
solAssert(retSizeOnStack == utils().sizeOnStack(returnTypes), "");
- solAssert(retSizeOnStack <= 15, "Stack is too deep.");
+ if (retSizeOnStack > 15)
+ BOOST_THROW_EXCEPTION(
+ CompilerError() <<
+ errinfo_sourceLocation(_varDecl.location()) <<
+ errinfo_comment("Stack too deep.")
+ );
m_context << dupInstruction(retSizeOnStack + 1);
m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction);
}
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index d5a4e554..e96e0126 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -252,16 +252,6 @@ bool CompilerStack::parseAndAnalyze()
return parse() && analyze();
}
-vector<string> CompilerStack::contractNames() const
-{
- if (m_stackState < AnalysisSuccessful)
- BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
- vector<string> contractNames;
- for (auto const& contract: m_contracts)
- contractNames.push_back(contract.first);
- return contractNames;
-}
-
bool CompilerStack::compile()
{
if (m_stackState < AnalysisSuccessful)
@@ -288,6 +278,16 @@ void CompilerStack::link()
}
}
+vector<string> CompilerStack::contractNames() const
+{
+ if (m_stackState < AnalysisSuccessful)
+ BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+ vector<string> contractNames;
+ for (auto const& contract: m_contracts)
+ contractNames.push_back(contract.first);
+ return contractNames;
+}
+
eth::AssemblyItems const* CompilerStack::assemblyItems(string const& _contractName) const
{
Contract const& currentContract = contract(_contractName);
@@ -753,9 +753,18 @@ string CompilerStack::createMetadata(Contract const& _contract) const
meta["language"] = "Solidity";
meta["compiler"]["version"] = VersionStringStrict;
+ /// All the source files (including self), which should be included in the metadata.
+ set<string> referencedSources;
+ referencedSources.insert(_contract.contract->sourceUnit().annotation().path);
+ for (auto const sourceUnit: _contract.contract->sourceUnit().referencedSourceUnits(true))
+ referencedSources.insert(sourceUnit->annotation().path);
+
meta["sources"] = Json::objectValue;
for (auto const& s: m_sources)
{
+ if (!referencedSources.count(s.first))
+ continue;
+
solAssert(s.second.scanner, "Scanner not available");
meta["sources"][s.first]["keccak256"] =
"0x" + toHex(dev::keccak256(s.second.scanner->source()).asBytes());
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index 356389db..d287f224 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -93,6 +93,17 @@ public:
m_errorList(),
m_errorReporter(m_errorList) {}
+ /// @returns the list of errors that occured during parsing and type checking.
+ ErrorList const& errors() { return m_errorReporter.errors(); }
+
+ /// @returns the current state.
+ State state() const { return m_stackState; }
+
+ /// Resets the compiler to a state where the sources are not parsed or even removed.
+ /// Sets the state to SourcesSet if @a _keepSources is true, otherwise to Empty.
+ /// All settings, with the exception of remappings, are reset.
+ void reset(bool _keepSources = false);
+
/// Sets path remappings in the format "context:prefix=target"
void setRemappings(std::vector<std::string> const& _remappings);
@@ -111,24 +122,23 @@ public:
m_optimizeRuns = _runs;
}
- /// Resets the compiler to a state where the sources are not parsed or even removed.
- /// Sets the state to SourcesSet if @a _keepSources is true, otherwise to Empty.
- /// All settings, with the exception of remappings, are reset.
- void reset(bool _keepSources = false);
-
/// Adds a source object (e.g. file) to the parser. After this, parse has to be called again.
/// @returns true if a source object by the name already existed and was replaced.
bool addSource(std::string const& _name, std::string const& _content, bool _isLibrary = false);
+
/// Parses all source units that were added
/// @returns false on error.
bool parse();
+
/// Performs the analysis steps (imports, scopesetting, syntaxCheck, referenceResolving,
/// typechecking, staticAnalysis) on previously set sources
/// @returns false on error.
bool analyze();
+
/// Parses and analyzes all source units that were added
/// @returns false on error.
bool parseAndAnalyze();
+
/// @returns a list of the contract names in the sources.
std::vector<std::string> contractNames() const;
@@ -136,43 +146,63 @@ public:
/// @returns false on error.
bool compile();
+ /// @returns the list of sources (paths) used
+ std::vector<std::string> sourceNames() const;
+
+ /// @returns a mapping assigning each source name its index inside the vector returned
+ /// by sourceNames().
+ std::map<std::string, unsigned> sourceIndices() const;
+
+ /// @returns the previously used scanner, useful for counting lines during error reporting.
+ Scanner const& scanner(std::string const& _sourceName = "") const;
+
+ /// @returns the parsed source unit with the supplied name.
+ SourceUnit const& ast(std::string const& _sourceName = "") const;
+
+ /// Helper function for logs printing. Do only use in error cases, it's quite expensive.
+ /// line and columns are numbered starting from 1 with following order:
+ /// start line, start column, end line, end column
+ std::tuple<int, int, int, int> positionFromSourceLocation(SourceLocation const& _sourceLocation) const;
+
+ /// @returns either the contract's name or a mixture of its name and source file, sanitized for filesystem use
+ std::string const filesystemFriendlyName(std::string const& _contractName) const;
+
/// @returns the assembled object for a contract.
eth::LinkerObject const& object(std::string const& _contractName = "") const;
+
/// @returns the runtime object for the contract.
eth::LinkerObject const& runtimeObject(std::string const& _contractName = "") const;
+
/// @returns the bytecode of a contract that uses an already deployed contract via DELEGATECALL.
/// The returned bytes will contain a sequence of 20 bytes of the format "XXX...XXX" which have to
/// substituted by the actual address. Note that this sequence starts end ends in three X
/// characters but can contain anything in between.
eth::LinkerObject const& cloneObject(std::string const& _contractName = "") const;
+
/// @returns normal contract assembly items
eth::AssemblyItems const* assemblyItems(std::string const& _contractName = "") const;
+
/// @returns runtime contract assembly items
eth::AssemblyItems const* runtimeAssemblyItems(std::string const& _contractName = "") const;
+
/// @returns the string that provides a mapping between bytecode and sourcecode or a nullptr
/// if the contract does not (yet) have bytecode.
std::string const* sourceMapping(std::string const& _contractName = "") const;
+
/// @returns the string that provides a mapping between runtime bytecode and sourcecode.
/// if the contract does not (yet) have bytecode.
std::string const* runtimeSourceMapping(std::string const& _contractName = "") const;
- /// @returns either the contract's name or a mixture of its name and source file, sanitized for filesystem use
- std::string const filesystemFriendlyName(std::string const& _contractName) const;
-
/// Streams a verbose version of the assembly to @a _outStream.
/// @arg _sourceCodes is the map of input files to source code strings
/// @arg _inJsonFromat shows whether the out should be in Json format
/// Prerequisite: Successful compilation.
Json::Value streamAssembly(std::ostream& _outStream, std::string const& _contractName = "", StringMap _sourceCodes = StringMap(), bool _inJsonFormat = false) const;
- /// @returns the list of sources (paths) used
- std::vector<std::string> sourceNames() const;
- /// @returns a mapping assigning each source name its index inside the vector returned
- /// by sourceNames().
- std::map<std::string, unsigned> sourceIndices() const;
/// @returns a JSON representing the contract ABI.
/// Prerequisite: Successful call to parse or compile.
Json::Value const& contractABI(std::string const& _contractName = "") const;
+
/// @returns a JSON representing the contract's documentation.
/// Prerequisite: Successful call to parse or compile.
/// @param type The type of the documentation to get.
@@ -182,28 +212,13 @@ public:
/// @returns a JSON representing a map of method identifiers (hashes) to function names.
Json::Value methodIdentifiers(std::string const& _contractName) const;
+ /// @returns the Contract Metadata
std::string const& metadata(std::string const& _contractName) const;
void useMetadataLiteralSources(bool _metadataLiteralSources) { m_metadataLiteralSources = _metadataLiteralSources; }
/// @returns a JSON representing the estimated gas usage for contract creation, internal and external functions
Json::Value gasEstimates(std::string const& _contractName) const;
- /// @returns the previously used scanner, useful for counting lines during error reporting.
- Scanner const& scanner(std::string const& _sourceName = "") const;
- /// @returns the parsed source unit with the supplied name.
- SourceUnit const& ast(std::string const& _sourceName = "") const;
-
- /// Helper function for logs printing. Do only use in error cases, it's quite expensive.
- /// line and columns are numbered starting from 1 with following order:
- /// start line, start column, end line, end column
- std::tuple<int, int, int, int> positionFromSourceLocation(SourceLocation const& _sourceLocation) const;
-
- /// @returns the list of errors that occured during parsing and type checking.
- ErrorList const& errors() { return m_errorReporter.errors(); }
-
- /// @returns the current state.
- State state() const { return m_stackState; }
-
private:
/**
* Information pertaining to one source unit, filled gradually during parsing and compilation.
@@ -230,6 +245,7 @@ private:
mutable std::unique_ptr<std::string const> sourceMapping;
mutable std::unique_ptr<std::string const> runtimeSourceMapping;
};
+
/// Loads the missing sources from @a _ast (named @a _path) using the callback
/// @a m_readFile and stores the absolute paths of all imports in the AST annotations.
/// @returns the newly loaded sources.
diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index 23687340..dd135ce5 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -285,24 +285,27 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
));
}
}
+ /// This is only thrown in a very few locations.
catch (Error const& _error)
{
- if (_error.type() == Error::Type::DocstringParsingError)
- errors.append(formatError(
- false,
- "DocstringParsingError",
- "general",
- "Documentation parsing error: " + *boost::get_error_info<errinfo_comment>(_error)
- ));
- else
- errors.append(formatErrorWithException(
- _error,
- false,
- _error.typeName(),
- "general",
- "",
- scannerFromSourceName
- ));
+ errors.append(formatErrorWithException(
+ _error,
+ false,
+ _error.typeName(),
+ "general",
+ "Uncaught error: ",
+ scannerFromSourceName
+ ));
+ }
+ /// This should not be leaked from compile().
+ catch (FatalError const& _exception)
+ {
+ errors.append(formatError(
+ false,
+ "FatalError",
+ "general",
+ "Uncaught fatal error: " + boost::diagnostic_information(_exception)
+ ));
}
catch (CompilerError const& _exception)
{
@@ -322,7 +325,8 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
false,
"InternalCompilerError",
"general",
- "Internal compiler error (" + _exception.lineInfo() + ")", scannerFromSourceName
+ "Internal compiler error (" + _exception.lineInfo() + ")",
+ scannerFromSourceName
));
}
catch (UnimplementedFeatureError const& _exception)
@@ -333,7 +337,8 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
"UnimplementedFeatureError",
"general",
"Unimplemented feature (" + _exception.lineInfo() + ")",
- scannerFromSourceName));
+ scannerFromSourceName
+ ));
}
catch (Exception const& _exception)
{
diff --git a/test/libevmasm/Optimiser.cpp b/test/libevmasm/Optimiser.cpp
new file mode 100644
index 00000000..5aa81af5
--- /dev/null
+++ b/test/libevmasm/Optimiser.cpp
@@ -0,0 +1,871 @@
+/*
+ This file is part of solidity.
+
+ solidity 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.
+
+ solidity 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 solidity. If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Tests for the Solidity optimizer.
+ */
+
+#include <libevmasm/CommonSubexpressionEliminator.h>
+#include <libevmasm/PeepholeOptimiser.h>
+#include <libevmasm/ControlFlowGraph.h>
+#include <libevmasm/BlockDeduplicator.h>
+#include <libevmasm/Assembly.h>
+
+#include <boost/test/unit_test.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <chrono>
+#include <string>
+#include <tuple>
+#include <memory>
+
+using namespace std;
+using namespace dev::eth;
+
+namespace dev
+{
+namespace solidity
+{
+namespace test
+{
+
+namespace
+{
+ AssemblyItems addDummyLocations(AssemblyItems const& _input)
+ {
+ // add dummy locations to each item so that we can check that they are not deleted
+ AssemblyItems input = _input;
+ for (AssemblyItem& item: input)
+ item.setLocation(SourceLocation(1, 3, make_shared<string>("")));
+ return input;
+ }
+
+ eth::KnownState createInitialState(AssemblyItems const& _input)
+ {
+ eth::KnownState state;
+ for (auto const& item: addDummyLocations(_input))
+ state.feedItem(item, true);
+ return state;
+ }
+
+ AssemblyItems CSE(AssemblyItems const& _input, eth::KnownState const& _state = eth::KnownState())
+ {
+ AssemblyItems input = addDummyLocations(_input);
+
+ eth::CommonSubexpressionEliminator cse(_state);
+ BOOST_REQUIRE(cse.feedItems(input.begin(), input.end()) == input.end());
+ AssemblyItems output = cse.getOptimizedItems();
+
+ for (AssemblyItem const& item: output)
+ {
+ BOOST_CHECK(item == Instruction::POP || !item.location().isEmpty());
+ }
+ return output;
+ }
+
+ void checkCSE(
+ AssemblyItems const& _input,
+ AssemblyItems const& _expectation,
+ KnownState const& _state = eth::KnownState()
+ )
+ {
+ AssemblyItems output = CSE(_input, _state);
+ BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
+ }
+
+ AssemblyItems CFG(AssemblyItems const& _input)
+ {
+ AssemblyItems output = _input;
+ // Running it four times should be enough for these tests.
+ for (unsigned i = 0; i < 4; ++i)
+ {
+ ControlFlowGraph cfg(output);
+ AssemblyItems optItems;
+ for (BasicBlock const& block: cfg.optimisedBlocks())
+ copy(output.begin() + block.begin, output.begin() + block.end,
+ back_inserter(optItems));
+ output = move(optItems);
+ }
+ return output;
+ }
+
+ void checkCFG(AssemblyItems const& _input, AssemblyItems const& _expectation)
+ {
+ AssemblyItems output = CFG(_input);
+ BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
+ }
+}
+
+BOOST_AUTO_TEST_SUITE(Optimiser)
+
+BOOST_AUTO_TEST_CASE(cse_intermediate_swap)
+{
+ eth::KnownState state;
+ eth::CommonSubexpressionEliminator cse(state);
+ AssemblyItems input{
+ Instruction::SWAP1, Instruction::POP, Instruction::ADD, u256(0), Instruction::SWAP1,
+ Instruction::SLOAD, Instruction::SWAP1, u256(100), Instruction::EXP, Instruction::SWAP1,
+ Instruction::DIV, u256(0xff), Instruction::AND
+ };
+ BOOST_REQUIRE(cse.feedItems(input.begin(), input.end()) == input.end());
+ AssemblyItems output = cse.getOptimizedItems();
+ BOOST_CHECK(!output.empty());
+}
+
+BOOST_AUTO_TEST_CASE(cse_negative_stack_access)
+{
+ AssemblyItems input{Instruction::DUP2, u256(0)};
+ checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_negative_stack_end)
+{
+ AssemblyItems input{Instruction::ADD};
+ checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_intermediate_negative_stack)
+{
+ AssemblyItems input{Instruction::ADD, u256(1), Instruction::DUP1};
+ checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_pop)
+{
+ checkCSE({Instruction::POP}, {Instruction::POP});
+}
+
+BOOST_AUTO_TEST_CASE(cse_unneeded_items)
+{
+ AssemblyItems input{
+ Instruction::ADD,
+ Instruction::SWAP1,
+ Instruction::POP,
+ u256(7),
+ u256(8),
+ };
+ checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_constant_addition)
+{
+ AssemblyItems input{u256(7), u256(8), Instruction::ADD};
+ checkCSE(input, {u256(7 + 8)});
+}
+
+BOOST_AUTO_TEST_CASE(cse_invariants)
+{
+ AssemblyItems input{
+ Instruction::DUP1,
+ Instruction::DUP1,
+ u256(0),
+ Instruction::OR,
+ Instruction::OR
+ };
+ checkCSE(input, {Instruction::DUP1});
+}
+
+BOOST_AUTO_TEST_CASE(cse_subself)
+{
+ checkCSE({Instruction::DUP1, Instruction::SUB}, {Instruction::POP, u256(0)});
+}
+
+BOOST_AUTO_TEST_CASE(cse_subother)
+{
+ checkCSE({Instruction::SUB}, {Instruction::SUB});
+}
+
+BOOST_AUTO_TEST_CASE(cse_double_negation)
+{
+ checkCSE({Instruction::DUP5, Instruction::NOT, Instruction::NOT}, {Instruction::DUP5});
+}
+
+BOOST_AUTO_TEST_CASE(cse_double_iszero)
+{
+ checkCSE({Instruction::GT, Instruction::ISZERO, Instruction::ISZERO}, {Instruction::GT});
+ checkCSE({Instruction::GT, Instruction::ISZERO}, {Instruction::GT, Instruction::ISZERO});
+ checkCSE(
+ {Instruction::ISZERO, Instruction::ISZERO, Instruction::ISZERO},
+ {Instruction::ISZERO}
+ );
+}
+
+BOOST_AUTO_TEST_CASE(cse_associativity)
+{
+ AssemblyItems input{
+ Instruction::DUP1,
+ Instruction::DUP1,
+ u256(0),
+ Instruction::OR,
+ Instruction::OR
+ };
+ checkCSE(input, {Instruction::DUP1});
+}
+
+BOOST_AUTO_TEST_CASE(cse_associativity2)
+{
+ AssemblyItems input{
+ u256(0),
+ Instruction::DUP2,
+ u256(2),
+ u256(1),
+ Instruction::DUP6,
+ Instruction::ADD,
+ u256(2),
+ Instruction::ADD,
+ Instruction::ADD,
+ Instruction::ADD,
+ Instruction::ADD
+ };
+ checkCSE(input, {Instruction::DUP2, Instruction::DUP2, Instruction::ADD, u256(5), Instruction::ADD});
+}
+
+BOOST_AUTO_TEST_CASE(cse_storage)
+{
+ AssemblyItems input{
+ u256(0),
+ Instruction::SLOAD,
+ u256(0),
+ Instruction::SLOAD,
+ Instruction::ADD,
+ u256(0),
+ Instruction::SSTORE
+ };
+ checkCSE(input, {
+ u256(0),
+ Instruction::DUP1,
+ Instruction::SLOAD,
+ Instruction::DUP1,
+ Instruction::ADD,
+ Instruction::SWAP1,
+ Instruction::SSTORE
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_noninterleaved_storage)
+{
+ // two stores to the same location should be replaced by only one store, even if we
+ // read in the meantime
+ AssemblyItems input{
+ u256(7),
+ Instruction::DUP2,
+ Instruction::SSTORE,
+ Instruction::DUP1,
+ Instruction::SLOAD,
+ u256(8),
+ Instruction::DUP3,
+ Instruction::SSTORE
+ };
+ checkCSE(input, {
+ u256(8),
+ Instruction::DUP2,
+ Instruction::SSTORE,
+ u256(7)
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage)
+{
+ // stores and reads to/from two unknown locations, should not optimize away the first store
+ AssemblyItems input{
+ u256(7),
+ Instruction::DUP2,
+ Instruction::SSTORE, // store to "DUP1"
+ Instruction::DUP2,
+ Instruction::SLOAD, // read from "DUP2", might be equal to "DUP1"
+ u256(0),
+ Instruction::DUP3,
+ Instruction::SSTORE // store different value to "DUP1"
+ };
+ checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage_same_value)
+{
+ // stores and reads to/from two unknown locations, should not optimize away the first store
+ // but it should optimize away the second, since we already know the value will be the same
+ AssemblyItems input{
+ u256(7),
+ Instruction::DUP2,
+ Instruction::SSTORE, // store to "DUP1"
+ Instruction::DUP2,
+ Instruction::SLOAD, // read from "DUP2", might be equal to "DUP1"
+ u256(6),
+ u256(1),
+ Instruction::ADD,
+ Instruction::DUP3,
+ Instruction::SSTORE // store same value to "DUP1"
+ };
+ checkCSE(input, {
+ u256(7),
+ Instruction::DUP2,
+ Instruction::SSTORE,
+ Instruction::DUP2,
+ Instruction::SLOAD
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage_at_known_location)
+{
+ // stores and reads to/from two known locations, should optimize away the first store,
+ // because we know that the location is different
+ AssemblyItems input{
+ u256(0x70),
+ u256(1),
+ Instruction::SSTORE, // store to 1
+ u256(2),
+ Instruction::SLOAD, // read from 2, is different from 1
+ u256(0x90),
+ u256(1),
+ Instruction::SSTORE // store different value at 1
+ };
+ checkCSE(input, {
+ u256(2),
+ Instruction::SLOAD,
+ u256(0x90),
+ u256(1),
+ Instruction::SSTORE
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_interleaved_storage_at_known_location_offset)
+{
+ // stores and reads to/from two locations which are known to be different,
+ // should optimize away the first store, because we know that the location is different
+ AssemblyItems input{
+ u256(0x70),
+ Instruction::DUP2,
+ u256(1),
+ Instruction::ADD,
+ Instruction::SSTORE, // store to "DUP1"+1
+ Instruction::DUP1,
+ u256(2),
+ Instruction::ADD,
+ Instruction::SLOAD, // read from "DUP1"+2, is different from "DUP1"+1
+ u256(0x90),
+ Instruction::DUP3,
+ u256(1),
+ Instruction::ADD,
+ Instruction::SSTORE // store different value at "DUP1"+1
+ };
+ checkCSE(input, {
+ u256(2),
+ Instruction::DUP2,
+ Instruction::ADD,
+ Instruction::SLOAD,
+ u256(0x90),
+ u256(1),
+ Instruction::DUP4,
+ Instruction::ADD,
+ Instruction::SSTORE
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_deep_stack)
+{
+ AssemblyItems input{
+ Instruction::ADD,
+ Instruction::SWAP1,
+ Instruction::POP,
+ Instruction::SWAP8,
+ Instruction::POP,
+ Instruction::SWAP8,
+ Instruction::POP,
+ Instruction::SWAP8,
+ Instruction::SWAP5,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ };
+ checkCSE(input, {
+ Instruction::SWAP4,
+ Instruction::SWAP12,
+ Instruction::SWAP3,
+ Instruction::SWAP11,
+ Instruction::POP,
+ Instruction::SWAP1,
+ Instruction::SWAP3,
+ Instruction::ADD,
+ Instruction::SWAP8,
+ Instruction::POP,
+ Instruction::SWAP6,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ Instruction::POP,
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_jumpi_no_jump)
+{
+ AssemblyItems input{
+ u256(0),
+ u256(1),
+ Instruction::DUP2,
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMPI
+ };
+ checkCSE(input, {
+ u256(0),
+ u256(1)
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_jumpi_jump)
+{
+ AssemblyItems input{
+ u256(1),
+ u256(1),
+ Instruction::DUP2,
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMPI
+ };
+ checkCSE(input, {
+ u256(1),
+ Instruction::DUP1,
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_empty_keccak256)
+{
+ AssemblyItems input{
+ u256(0),
+ Instruction::DUP2,
+ Instruction::KECCAK256
+ };
+ checkCSE(input, {
+ u256(dev::keccak256(bytesConstRef()))
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_partial_keccak256)
+{
+ AssemblyItems input{
+ u256(0xabcd) << (256 - 16),
+ u256(0),
+ Instruction::MSTORE,
+ u256(2),
+ u256(0),
+ Instruction::KECCAK256
+ };
+ checkCSE(input, {
+ u256(0xabcd) << (256 - 16),
+ u256(0),
+ Instruction::MSTORE,
+ u256(dev::keccak256(bytes{0xab, 0xcd}))
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_location)
+{
+ // Keccak-256 twice from same dynamic location
+ AssemblyItems input{
+ Instruction::DUP2,
+ Instruction::DUP1,
+ Instruction::MSTORE,
+ u256(64),
+ Instruction::DUP2,
+ Instruction::KECCAK256,
+ u256(64),
+ Instruction::DUP3,
+ Instruction::KECCAK256
+ };
+ checkCSE(input, {
+ Instruction::DUP2,
+ Instruction::DUP1,
+ Instruction::MSTORE,
+ u256(64),
+ Instruction::DUP2,
+ Instruction::KECCAK256,
+ Instruction::DUP1
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content)
+{
+ // Keccak-256 twice from different dynamic location but with same content
+ AssemblyItems input{
+ Instruction::DUP1,
+ u256(0x80),
+ Instruction::MSTORE, // m[128] = DUP1
+ u256(0x20),
+ u256(0x80),
+ Instruction::KECCAK256, // keccak256(m[128..(128+32)])
+ Instruction::DUP2,
+ u256(12),
+ Instruction::MSTORE, // m[12] = DUP1
+ u256(0x20),
+ u256(12),
+ Instruction::KECCAK256 // keccak256(m[12..(12+32)])
+ };
+ checkCSE(input, {
+ u256(0x80),
+ Instruction::DUP2,
+ Instruction::DUP2,
+ Instruction::MSTORE,
+ u256(0x20),
+ Instruction::SWAP1,
+ Instruction::KECCAK256,
+ u256(12),
+ Instruction::DUP3,
+ Instruction::SWAP1,
+ Instruction::MSTORE,
+ Instruction::DUP1
+ });
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content_dynamic_store_in_between)
+{
+ // Keccak-256 twice from different dynamic location but with same content,
+ // dynamic mstore in between, which forces us to re-calculate the hash
+ AssemblyItems input{
+ u256(0x80),
+ Instruction::DUP2,
+ Instruction::DUP2,
+ Instruction::MSTORE, // m[128] = DUP1
+ u256(0x20),
+ Instruction::DUP1,
+ Instruction::DUP3,
+ Instruction::KECCAK256, // keccak256(m[128..(128+32)])
+ u256(12),
+ Instruction::DUP5,
+ Instruction::DUP2,
+ Instruction::MSTORE, // m[12] = DUP1
+ Instruction::DUP12,
+ Instruction::DUP14,
+ Instruction::MSTORE, // destroys memory knowledge
+ Instruction::SWAP2,
+ Instruction::SWAP1,
+ Instruction::SWAP2,
+ Instruction::KECCAK256 // keccak256(m[12..(12+32)])
+ };
+ checkCSE(input, input);
+}
+
+BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content_noninterfering_store_in_between)
+{
+ // Keccak-256 twice from different dynamic location but with same content,
+ // dynamic mstore in between, but does not force us to re-calculate the hash
+ AssemblyItems input{
+ u256(0x80),
+ Instruction::DUP2,
+ Instruction::DUP2,
+ Instruction::MSTORE, // m[128] = DUP1
+ u256(0x20),
+ Instruction::DUP1,
+ Instruction::DUP3,
+ Instruction::KECCAK256, // keccak256(m[128..(128+32)])
+ u256(12),
+ Instruction::DUP5,
+ Instruction::DUP2,
+ Instruction::MSTORE, // m[12] = DUP1
+ Instruction::DUP12,
+ u256(12 + 32),
+ Instruction::MSTORE, // does not destoy memory knowledge
+ Instruction::DUP13,
+ u256(128 - 32),
+ Instruction::MSTORE, // does not destoy memory knowledge
+ u256(0x20),
+ u256(12),
+ Instruction::KECCAK256 // keccak256(m[12..(12+32)])
+ };
+ // if this changes too often, only count the number of SHA3 and MSTORE instructions
+ AssemblyItems output = CSE(input);
+ BOOST_CHECK_EQUAL(4, count(output.begin(), output.end(), AssemblyItem(Instruction::MSTORE)));
+ BOOST_CHECK_EQUAL(1, count(output.begin(), output.end(), AssemblyItem(Instruction::KECCAK256)));
+}
+
+BOOST_AUTO_TEST_CASE(cse_with_initially_known_stack)
+{
+ eth::KnownState state = createInitialState(AssemblyItems{
+ u256(0x12),
+ u256(0x20),
+ Instruction::ADD
+ });
+ AssemblyItems input{
+ u256(0x12 + 0x20)
+ };
+ checkCSE(input, AssemblyItems{Instruction::DUP1}, state);
+}
+
+BOOST_AUTO_TEST_CASE(cse_equality_on_initially_known_stack)
+{
+ eth::KnownState state = createInitialState(AssemblyItems{Instruction::DUP1});
+ AssemblyItems input{
+ Instruction::EQ
+ };
+ AssemblyItems output = CSE(input, state);
+ // check that it directly pushes 1 (true)
+ BOOST_CHECK(find(output.begin(), output.end(), AssemblyItem(u256(1))) != output.end());
+}
+
+BOOST_AUTO_TEST_CASE(cse_access_previous_sequence)
+{
+ // Tests that the code generator detects whether it tries to access SLOAD instructions
+ // from a sequenced expression which is not in its scope.
+ eth::KnownState state = createInitialState(AssemblyItems{
+ u256(0),
+ Instruction::SLOAD,
+ u256(1),
+ Instruction::ADD,
+ u256(0),
+ Instruction::SSTORE
+ });
+ // now stored: val_1 + 1 (value at sequence 1)
+ // if in the following instructions, the SLOAD cresolves to "val_1 + 1",
+ // this cannot be generated because we cannot load from sequence 1 anymore.
+ AssemblyItems input{
+ u256(0),
+ Instruction::SLOAD,
+ };
+ BOOST_CHECK_THROW(CSE(input, state), StackTooDeepException);
+ // @todo for now, this throws an exception, but it should recover to the following
+ // (or an even better version) at some point:
+ // 0, SLOAD, 1, ADD, SSTORE, 0 SLOAD
+}
+
+BOOST_AUTO_TEST_CASE(cse_optimise_return)
+{
+ checkCSE(
+ AssemblyItems{u256(0), u256(7), Instruction::RETURN},
+ AssemblyItems{Instruction::STOP}
+ );
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_remove_unused)
+{
+ // remove parts of the code that are unused
+ AssemblyItems input{
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ u256(7),
+ AssemblyItem(Tag, 1),
+ };
+ checkCFG(input, {});
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_remove_unused_loop)
+{
+ AssemblyItems input{
+ AssemblyItem(PushTag, 3),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 1),
+ u256(7),
+ AssemblyItem(PushTag, 2),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 2),
+ u256(8),
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 3),
+ u256(11)
+ };
+ checkCFG(input, {u256(11)});
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_reconnect_single_jump_source)
+{
+ // move code that has only one unconditional jump source
+ AssemblyItems input{
+ u256(1),
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 2),
+ u256(2),
+ AssemblyItem(PushTag, 3),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 1),
+ u256(3),
+ AssemblyItem(PushTag, 2),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 3),
+ u256(4),
+ };
+ checkCFG(input, {u256(1), u256(3), u256(2), u256(4)});
+}
+
+BOOST_AUTO_TEST_CASE(control_flow_graph_do_not_remove_returned_to)
+{
+ // do not remove parts that are "returned to"
+ AssemblyItems input{
+ AssemblyItem(PushTag, 1),
+ AssemblyItem(PushTag, 2),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 2),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 1),
+ u256(2)
+ };
+ checkCFG(input, {u256(2)});
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator)
+{
+ AssemblyItems input{
+ AssemblyItem(PushTag, 2),
+ AssemblyItem(PushTag, 1),
+ AssemblyItem(PushTag, 3),
+ u256(6),
+ Instruction::SWAP3,
+ Instruction::JUMP,
+ AssemblyItem(Tag, 1),
+ u256(6),
+ Instruction::SWAP3,
+ Instruction::JUMP,
+ AssemblyItem(Tag, 2),
+ u256(6),
+ Instruction::SWAP3,
+ Instruction::JUMP,
+ AssemblyItem(Tag, 3)
+ };
+ BlockDeduplicator dedup(input);
+ dedup.deduplicate();
+
+ set<u256> pushTags;
+ for (AssemblyItem const& item: input)
+ if (item.type() == PushTag)
+ pushTags.insert(item.data());
+ BOOST_CHECK_EQUAL(pushTags.size(), 2);
+}
+
+BOOST_AUTO_TEST_CASE(block_deduplicator_loops)
+{
+ AssemblyItems input{
+ u256(0),
+ Instruction::SLOAD,
+ AssemblyItem(PushTag, 1),
+ AssemblyItem(PushTag, 2),
+ Instruction::JUMPI,
+ Instruction::JUMP,
+ AssemblyItem(Tag, 1),
+ u256(5),
+ u256(6),
+ Instruction::SSTORE,
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 2),
+ u256(5),
+ u256(6),
+ Instruction::SSTORE,
+ AssemblyItem(PushTag, 2),
+ Instruction::JUMP,
+ };
+ BlockDeduplicator dedup(input);
+ dedup.deduplicate();
+
+ set<u256> pushTags;
+ for (AssemblyItem const& item: input)
+ if (item.type() == PushTag)
+ pushTags.insert(item.data());
+ BOOST_CHECK_EQUAL(pushTags.size(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(clear_unreachable_code)
+{
+ AssemblyItems items{
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ u256(0),
+ Instruction::SLOAD,
+ AssemblyItem(Tag, 2),
+ u256(5),
+ u256(6),
+ Instruction::SSTORE,
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ u256(5),
+ u256(6)
+ };
+ AssemblyItems expectation{
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP,
+ AssemblyItem(Tag, 2),
+ u256(5),
+ u256(6),
+ Instruction::SSTORE,
+ AssemblyItem(PushTag, 1),
+ Instruction::JUMP
+ };
+ PeepholeOptimiser peepOpt(items);
+ BOOST_REQUIRE(peepOpt.optimise());
+ BOOST_CHECK_EQUAL_COLLECTIONS(
+ items.begin(), items.end(),
+ expectation.begin(), expectation.end()
+ );
+}
+
+BOOST_AUTO_TEST_CASE(peephole_double_push)
+{
+ AssemblyItems items{
+ u256(0),
+ u256(0),
+ u256(5),
+ u256(5),
+ u256(4),
+ u256(5)
+ };
+ AssemblyItems expectation{
+ u256(0),
+ Instruction::DUP1,
+ u256(5),
+ Instruction::DUP1,
+ u256(4),
+ u256(5)
+ };
+ PeepholeOptimiser peepOpt(items);
+ BOOST_REQUIRE(peepOpt.optimise());
+ BOOST_CHECK_EQUAL_COLLECTIONS(
+ items.begin(), items.end(),
+ expectation.begin(), expectation.end()
+ );
+}
+
+BOOST_AUTO_TEST_CASE(cse_sub_zero)
+{
+ checkCSE({
+ u256(0),
+ Instruction::DUP2,
+ Instruction::SUB
+ }, {
+ Instruction::DUP1
+ });
+
+ checkCSE({
+ Instruction::DUP1,
+ u256(0),
+ Instruction::SUB
+ }, {
+ u256(0),
+ Instruction::DUP2,
+ Instruction::SWAP1,
+ Instruction::SUB
+ });
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}
+}
+} // end namespaces
diff --git a/test/libsolidity/Metadata.cpp b/test/libsolidity/Metadata.cpp
index e4820ad2..0d3caddd 100644
--- a/test/libsolidity/Metadata.cpp
+++ b/test/libsolidity/Metadata.cpp
@@ -58,6 +58,75 @@ BOOST_AUTO_TEST_CASE(metadata_stamp)
BOOST_CHECK(std::equal(expectation.begin(), expectation.end(), bytecode.end() - metadataCBORSize - 2));
}
+BOOST_AUTO_TEST_CASE(metadata_relevant_sources)
+{
+ CompilerStack compilerStack;
+ char const* sourceCode = R"(
+ pragma solidity >=0.0;
+ contract A {
+ function g(function(uint) external returns (uint) x) {}
+ }
+ )";
+ compilerStack.addSource("A", std::string(sourceCode));
+ sourceCode = R"(
+ pragma solidity >=0.0;
+ contract B {
+ function g(function(uint) external returns (uint) x) {}
+ }
+ )";
+ compilerStack.addSource("B", std::string(sourceCode));
+ compilerStack.setOptimiserSettings(dev::test::Options::get().optimize);
+ ETH_TEST_REQUIRE_NO_THROW(compilerStack.compile(), "Compiling contract failed");
+
+ std::string const& serialisedMetadata = compilerStack.metadata("A");
+ BOOST_CHECK(dev::test::isValidMetadata(serialisedMetadata));
+ Json::Value metadata;
+ BOOST_REQUIRE(Json::Reader().parse(serialisedMetadata, metadata, false));
+
+ BOOST_CHECK_EQUAL(metadata["sources"].size(), 1);
+ BOOST_CHECK(metadata["sources"].isMember("A"));
+}
+
+BOOST_AUTO_TEST_CASE(metadata_relevant_sources_imports)
+{
+ CompilerStack compilerStack;
+ char const* sourceCode = R"(
+ pragma solidity >=0.0;
+ contract A {
+ function g(function(uint) external returns (uint) x) {}
+ }
+ )";
+ compilerStack.addSource("A", std::string(sourceCode));
+ sourceCode = R"(
+ pragma solidity >=0.0;
+ import "./A";
+ contract B is A {
+ function g(function(uint) external returns (uint) x) {}
+ }
+ )";
+ compilerStack.addSource("B", std::string(sourceCode));
+ sourceCode = R"(
+ pragma solidity >=0.0;
+ import "./B";
+ contract C is B {
+ function g(function(uint) external returns (uint) x) {}
+ }
+ )";
+ compilerStack.addSource("C", std::string(sourceCode));
+ compilerStack.setOptimiserSettings(dev::test::Options::get().optimize);
+ ETH_TEST_REQUIRE_NO_THROW(compilerStack.compile(), "Compiling contract failed");
+
+ std::string const& serialisedMetadata = compilerStack.metadata("C");
+ BOOST_CHECK(dev::test::isValidMetadata(serialisedMetadata));
+ Json::Value metadata;
+ BOOST_REQUIRE(Json::Reader().parse(serialisedMetadata, metadata, false));
+
+ BOOST_CHECK_EQUAL(metadata["sources"].size(), 3);
+ BOOST_CHECK(metadata["sources"].isMember("A"));
+ BOOST_CHECK(metadata["sources"].isMember("B"));
+ BOOST_CHECK(metadata["sources"].isMember("C"));
+}
+
BOOST_AUTO_TEST_SUITE_END()
}
diff --git a/test/libsolidity/SolidityOptimizer.cpp b/test/libsolidity/SolidityOptimizer.cpp
index a4d80c99..bd635c33 100644
--- a/test/libsolidity/SolidityOptimizer.cpp
+++ b/test/libsolidity/SolidityOptimizer.cpp
@@ -22,11 +22,7 @@
#include <test/libsolidity/SolidityExecutionFramework.h>
-#include <libevmasm/CommonSubexpressionEliminator.h>
-#include <libevmasm/PeepholeOptimiser.h>
-#include <libevmasm/ControlFlowGraph.h>
-#include <libevmasm/Assembly.h>
-#include <libevmasm/BlockDeduplicator.h>
+#include <libevmasm/Instruction.h>
#include <boost/test/unit_test.hpp>
#include <boost/lexical_cast.hpp>
@@ -106,71 +102,6 @@ public:
"\nOptimized: " + toHex(optimizedOutput));
}
- AssemblyItems addDummyLocations(AssemblyItems const& _input)
- {
- // add dummy locations to each item so that we can check that they are not deleted
- AssemblyItems input = _input;
- for (AssemblyItem& item: input)
- item.setLocation(SourceLocation(1, 3, make_shared<string>("")));
- return input;
- }
-
- eth::KnownState createInitialState(AssemblyItems const& _input)
- {
- eth::KnownState state;
- for (auto const& item: addDummyLocations(_input))
- state.feedItem(item, true);
- return state;
- }
-
- AssemblyItems CSE(AssemblyItems const& _input, eth::KnownState const& _state = eth::KnownState())
- {
- AssemblyItems input = addDummyLocations(_input);
-
- eth::CommonSubexpressionEliminator cse(_state);
- BOOST_REQUIRE(cse.feedItems(input.begin(), input.end()) == input.end());
- AssemblyItems output = cse.getOptimizedItems();
-
- for (AssemblyItem const& item: output)
- {
- BOOST_CHECK(item == Instruction::POP || !item.location().isEmpty());
- }
- return output;
- }
-
- void checkCSE(
- AssemblyItems const& _input,
- AssemblyItems const& _expectation,
- KnownState const& _state = eth::KnownState()
- )
- {
- AssemblyItems output = CSE(_input, _state);
- BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
- }
-
- AssemblyItems CFG(AssemblyItems const& _input)
- {
- AssemblyItems output = _input;
- // Running it four times should be enough for these tests.
- for (unsigned i = 0; i < 4; ++i)
- {
- ControlFlowGraph cfg(output);
- AssemblyItems optItems;
- for (BasicBlock const& block: cfg.optimisedBlocks())
- copy(output.begin() + block.begin, output.begin() + block.end,
- back_inserter(optItems));
- output = move(optItems);
- }
- return output;
- }
-
- void checkCFG(AssemblyItems const& _input, AssemblyItems const& _expectation)
- {
- AssemblyItems output = CFG(_input);
- BOOST_CHECK_EQUAL_COLLECTIONS(_expectation.begin(), _expectation.end(), output.begin(), output.end());
- }
-
-protected:
/// @returns the number of intructions in the given bytecode, not taking the metadata hash
/// into account.
size_t numInstructions(bytes const& _bytecode)
@@ -187,6 +118,7 @@ protected:
return instructions;
}
+protected:
Address m_optimizedContract;
Address m_nonOptimizedContract;
};
@@ -434,734 +366,6 @@ BOOST_AUTO_TEST_CASE(sequence_number_for_calls)
compareVersions("f(string,string)", 0x40, 0x80, 3, "abc", 3, "def");
}
-BOOST_AUTO_TEST_CASE(cse_intermediate_swap)
-{
- eth::KnownState state;
- eth::CommonSubexpressionEliminator cse(state);
- AssemblyItems input{
- Instruction::SWAP1, Instruction::POP, Instruction::ADD, u256(0), Instruction::SWAP1,
- Instruction::SLOAD, Instruction::SWAP1, u256(100), Instruction::EXP, Instruction::SWAP1,
- Instruction::DIV, u256(0xff), Instruction::AND
- };
- BOOST_REQUIRE(cse.feedItems(input.begin(), input.end()) == input.end());
- AssemblyItems output = cse.getOptimizedItems();
- BOOST_CHECK(!output.empty());
-}
-
-BOOST_AUTO_TEST_CASE(cse_negative_stack_access)
-{
- AssemblyItems input{Instruction::DUP2, u256(0)};
- checkCSE(input, input);
-}
-
-BOOST_AUTO_TEST_CASE(cse_negative_stack_end)
-{
- AssemblyItems input{Instruction::ADD};
- checkCSE(input, input);
-}
-
-BOOST_AUTO_TEST_CASE(cse_intermediate_negative_stack)
-{
- AssemblyItems input{Instruction::ADD, u256(1), Instruction::DUP1};
- checkCSE(input, input);
-}
-
-BOOST_AUTO_TEST_CASE(cse_pop)
-{
- checkCSE({Instruction::POP}, {Instruction::POP});
-}
-
-BOOST_AUTO_TEST_CASE(cse_unneeded_items)
-{
- AssemblyItems input{
- Instruction::ADD,
- Instruction::SWAP1,
- Instruction::POP,
- u256(7),
- u256(8),
- };
- checkCSE(input, input);
-}
-
-BOOST_AUTO_TEST_CASE(cse_constant_addition)
-{
- AssemblyItems input{u256(7), u256(8), Instruction::ADD};
- checkCSE(input, {u256(7 + 8)});
-}
-
-BOOST_AUTO_TEST_CASE(cse_invariants)
-{
- AssemblyItems input{
- Instruction::DUP1,
- Instruction::DUP1,
- u256(0),
- Instruction::OR,
- Instruction::OR
- };
- checkCSE(input, {Instruction::DUP1});
-}
-
-BOOST_AUTO_TEST_CASE(cse_subself)
-{
- checkCSE({Instruction::DUP1, Instruction::SUB}, {Instruction::POP, u256(0)});
-}
-
-BOOST_AUTO_TEST_CASE(cse_subother)
-{
- checkCSE({Instruction::SUB}, {Instruction::SUB});
-}
-
-BOOST_AUTO_TEST_CASE(cse_double_negation)
-{
- checkCSE({Instruction::DUP5, Instruction::NOT, Instruction::NOT}, {Instruction::DUP5});
-}
-
-BOOST_AUTO_TEST_CASE(cse_double_iszero)
-{
- checkCSE({Instruction::GT, Instruction::ISZERO, Instruction::ISZERO}, {Instruction::GT});
- checkCSE({Instruction::GT, Instruction::ISZERO}, {Instruction::GT, Instruction::ISZERO});
- checkCSE(
- {Instruction::ISZERO, Instruction::ISZERO, Instruction::ISZERO},
- {Instruction::ISZERO}
- );
-}
-
-BOOST_AUTO_TEST_CASE(cse_associativity)
-{
- AssemblyItems input{
- Instruction::DUP1,
- Instruction::DUP1,
- u256(0),
- Instruction::OR,
- Instruction::OR
- };
- checkCSE(input, {Instruction::DUP1});
-}
-
-BOOST_AUTO_TEST_CASE(cse_associativity2)
-{
- AssemblyItems input{
- u256(0),
- Instruction::DUP2,
- u256(2),
- u256(1),
- Instruction::DUP6,
- Instruction::ADD,
- u256(2),
- Instruction::ADD,
- Instruction::ADD,
- Instruction::ADD,
- Instruction::ADD
- };
- checkCSE(input, {Instruction::DUP2, Instruction::DUP2, Instruction::ADD, u256(5), Instruction::ADD});
-}
-
-BOOST_AUTO_TEST_CASE(cse_storage)
-{
- AssemblyItems input{
- u256(0),
- Instruction::SLOAD,
- u256(0),
- Instruction::SLOAD,
- Instruction::ADD,
- u256(0),
- Instruction::SSTORE
- };
- checkCSE(input, {
- u256(0),
- Instruction::DUP1,
- Instruction::SLOAD,
- Instruction::DUP1,
- Instruction::ADD,
- Instruction::SWAP1,
- Instruction::SSTORE
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_noninterleaved_storage)
-{
- // two stores to the same location should be replaced by only one store, even if we
- // read in the meantime
- AssemblyItems input{
- u256(7),
- Instruction::DUP2,
- Instruction::SSTORE,
- Instruction::DUP1,
- Instruction::SLOAD,
- u256(8),
- Instruction::DUP3,
- Instruction::SSTORE
- };
- checkCSE(input, {
- u256(8),
- Instruction::DUP2,
- Instruction::SSTORE,
- u256(7)
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_interleaved_storage)
-{
- // stores and reads to/from two unknown locations, should not optimize away the first store
- AssemblyItems input{
- u256(7),
- Instruction::DUP2,
- Instruction::SSTORE, // store to "DUP1"
- Instruction::DUP2,
- Instruction::SLOAD, // read from "DUP2", might be equal to "DUP1"
- u256(0),
- Instruction::DUP3,
- Instruction::SSTORE // store different value to "DUP1"
- };
- checkCSE(input, input);
-}
-
-BOOST_AUTO_TEST_CASE(cse_interleaved_storage_same_value)
-{
- // stores and reads to/from two unknown locations, should not optimize away the first store
- // but it should optimize away the second, since we already know the value will be the same
- AssemblyItems input{
- u256(7),
- Instruction::DUP2,
- Instruction::SSTORE, // store to "DUP1"
- Instruction::DUP2,
- Instruction::SLOAD, // read from "DUP2", might be equal to "DUP1"
- u256(6),
- u256(1),
- Instruction::ADD,
- Instruction::DUP3,
- Instruction::SSTORE // store same value to "DUP1"
- };
- checkCSE(input, {
- u256(7),
- Instruction::DUP2,
- Instruction::SSTORE,
- Instruction::DUP2,
- Instruction::SLOAD
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_interleaved_storage_at_known_location)
-{
- // stores and reads to/from two known locations, should optimize away the first store,
- // because we know that the location is different
- AssemblyItems input{
- u256(0x70),
- u256(1),
- Instruction::SSTORE, // store to 1
- u256(2),
- Instruction::SLOAD, // read from 2, is different from 1
- u256(0x90),
- u256(1),
- Instruction::SSTORE // store different value at 1
- };
- checkCSE(input, {
- u256(2),
- Instruction::SLOAD,
- u256(0x90),
- u256(1),
- Instruction::SSTORE
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_interleaved_storage_at_known_location_offset)
-{
- // stores and reads to/from two locations which are known to be different,
- // should optimize away the first store, because we know that the location is different
- AssemblyItems input{
- u256(0x70),
- Instruction::DUP2,
- u256(1),
- Instruction::ADD,
- Instruction::SSTORE, // store to "DUP1"+1
- Instruction::DUP1,
- u256(2),
- Instruction::ADD,
- Instruction::SLOAD, // read from "DUP1"+2, is different from "DUP1"+1
- u256(0x90),
- Instruction::DUP3,
- u256(1),
- Instruction::ADD,
- Instruction::SSTORE // store different value at "DUP1"+1
- };
- checkCSE(input, {
- u256(2),
- Instruction::DUP2,
- Instruction::ADD,
- Instruction::SLOAD,
- u256(0x90),
- u256(1),
- Instruction::DUP4,
- Instruction::ADD,
- Instruction::SSTORE
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_deep_stack)
-{
- AssemblyItems input{
- Instruction::ADD,
- Instruction::SWAP1,
- Instruction::POP,
- Instruction::SWAP8,
- Instruction::POP,
- Instruction::SWAP8,
- Instruction::POP,
- Instruction::SWAP8,
- Instruction::SWAP5,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- };
- checkCSE(input, {
- Instruction::SWAP4,
- Instruction::SWAP12,
- Instruction::SWAP3,
- Instruction::SWAP11,
- Instruction::POP,
- Instruction::SWAP1,
- Instruction::SWAP3,
- Instruction::ADD,
- Instruction::SWAP8,
- Instruction::POP,
- Instruction::SWAP6,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- Instruction::POP,
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_jumpi_no_jump)
-{
- AssemblyItems input{
- u256(0),
- u256(1),
- Instruction::DUP2,
- AssemblyItem(PushTag, 1),
- Instruction::JUMPI
- };
- checkCSE(input, {
- u256(0),
- u256(1)
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_jumpi_jump)
-{
- AssemblyItems input{
- u256(1),
- u256(1),
- Instruction::DUP2,
- AssemblyItem(PushTag, 1),
- Instruction::JUMPI
- };
- checkCSE(input, {
- u256(1),
- Instruction::DUP1,
- AssemblyItem(PushTag, 1),
- Instruction::JUMP
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_empty_keccak256)
-{
- AssemblyItems input{
- u256(0),
- Instruction::DUP2,
- Instruction::KECCAK256
- };
- checkCSE(input, {
- u256(dev::keccak256(bytesConstRef()))
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_partial_keccak256)
-{
- AssemblyItems input{
- u256(0xabcd) << (256 - 16),
- u256(0),
- Instruction::MSTORE,
- u256(2),
- u256(0),
- Instruction::KECCAK256
- };
- checkCSE(input, {
- u256(0xabcd) << (256 - 16),
- u256(0),
- Instruction::MSTORE,
- u256(dev::keccak256(bytes{0xab, 0xcd}))
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_location)
-{
- // Keccak-256 twice from same dynamic location
- AssemblyItems input{
- Instruction::DUP2,
- Instruction::DUP1,
- Instruction::MSTORE,
- u256(64),
- Instruction::DUP2,
- Instruction::KECCAK256,
- u256(64),
- Instruction::DUP3,
- Instruction::KECCAK256
- };
- checkCSE(input, {
- Instruction::DUP2,
- Instruction::DUP1,
- Instruction::MSTORE,
- u256(64),
- Instruction::DUP2,
- Instruction::KECCAK256,
- Instruction::DUP1
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content)
-{
- // Keccak-256 twice from different dynamic location but with same content
- AssemblyItems input{
- Instruction::DUP1,
- u256(0x80),
- Instruction::MSTORE, // m[128] = DUP1
- u256(0x20),
- u256(0x80),
- Instruction::KECCAK256, // keccak256(m[128..(128+32)])
- Instruction::DUP2,
- u256(12),
- Instruction::MSTORE, // m[12] = DUP1
- u256(0x20),
- u256(12),
- Instruction::KECCAK256 // keccak256(m[12..(12+32)])
- };
- checkCSE(input, {
- u256(0x80),
- Instruction::DUP2,
- Instruction::DUP2,
- Instruction::MSTORE,
- u256(0x20),
- Instruction::SWAP1,
- Instruction::KECCAK256,
- u256(12),
- Instruction::DUP3,
- Instruction::SWAP1,
- Instruction::MSTORE,
- Instruction::DUP1
- });
-}
-
-BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content_dynamic_store_in_between)
-{
- // Keccak-256 twice from different dynamic location but with same content,
- // dynamic mstore in between, which forces us to re-calculate the hash
- AssemblyItems input{
- u256(0x80),
- Instruction::DUP2,
- Instruction::DUP2,
- Instruction::MSTORE, // m[128] = DUP1
- u256(0x20),
- Instruction::DUP1,
- Instruction::DUP3,
- Instruction::KECCAK256, // keccak256(m[128..(128+32)])
- u256(12),
- Instruction::DUP5,
- Instruction::DUP2,
- Instruction::MSTORE, // m[12] = DUP1
- Instruction::DUP12,
- Instruction::DUP14,
- Instruction::MSTORE, // destroys memory knowledge
- Instruction::SWAP2,
- Instruction::SWAP1,
- Instruction::SWAP2,
- Instruction::KECCAK256 // keccak256(m[12..(12+32)])
- };
- checkCSE(input, input);
-}
-
-BOOST_AUTO_TEST_CASE(cse_keccak256_twice_same_content_noninterfering_store_in_between)
-{
- // Keccak-256 twice from different dynamic location but with same content,
- // dynamic mstore in between, but does not force us to re-calculate the hash
- AssemblyItems input{
- u256(0x80),
- Instruction::DUP2,
- Instruction::DUP2,
- Instruction::MSTORE, // m[128] = DUP1
- u256(0x20),
- Instruction::DUP1,
- Instruction::DUP3,
- Instruction::KECCAK256, // keccak256(m[128..(128+32)])
- u256(12),
- Instruction::DUP5,
- Instruction::DUP2,
- Instruction::MSTORE, // m[12] = DUP1
- Instruction::DUP12,
- u256(12 + 32),
- Instruction::MSTORE, // does not destoy memory knowledge
- Instruction::DUP13,
- u256(128 - 32),
- Instruction::MSTORE, // does not destoy memory knowledge
- u256(0x20),
- u256(12),
- Instruction::KECCAK256 // keccak256(m[12..(12+32)])
- };
- // if this changes too often, only count the number of SHA3 and MSTORE instructions
- AssemblyItems output = CSE(input);
- BOOST_CHECK_EQUAL(4, count(output.begin(), output.end(), AssemblyItem(Instruction::MSTORE)));
- BOOST_CHECK_EQUAL(1, count(output.begin(), output.end(), AssemblyItem(Instruction::KECCAK256)));
-}
-
-BOOST_AUTO_TEST_CASE(cse_with_initially_known_stack)
-{
- eth::KnownState state = createInitialState(AssemblyItems{
- u256(0x12),
- u256(0x20),
- Instruction::ADD
- });
- AssemblyItems input{
- u256(0x12 + 0x20)
- };
- checkCSE(input, AssemblyItems{Instruction::DUP1}, state);
-}
-
-BOOST_AUTO_TEST_CASE(cse_equality_on_initially_known_stack)
-{
- eth::KnownState state = createInitialState(AssemblyItems{Instruction::DUP1});
- AssemblyItems input{
- Instruction::EQ
- };
- AssemblyItems output = CSE(input, state);
- // check that it directly pushes 1 (true)
- BOOST_CHECK(find(output.begin(), output.end(), AssemblyItem(u256(1))) != output.end());
-}
-
-BOOST_AUTO_TEST_CASE(cse_access_previous_sequence)
-{
- // Tests that the code generator detects whether it tries to access SLOAD instructions
- // from a sequenced expression which is not in its scope.
- eth::KnownState state = createInitialState(AssemblyItems{
- u256(0),
- Instruction::SLOAD,
- u256(1),
- Instruction::ADD,
- u256(0),
- Instruction::SSTORE
- });
- // now stored: val_1 + 1 (value at sequence 1)
- // if in the following instructions, the SLOAD cresolves to "val_1 + 1",
- // this cannot be generated because we cannot load from sequence 1 anymore.
- AssemblyItems input{
- u256(0),
- Instruction::SLOAD,
- };
- BOOST_CHECK_THROW(CSE(input, state), StackTooDeepException);
- // @todo for now, this throws an exception, but it should recover to the following
- // (or an even better version) at some point:
- // 0, SLOAD, 1, ADD, SSTORE, 0 SLOAD
-}
-
-BOOST_AUTO_TEST_CASE(cse_optimise_return)
-{
- checkCSE(
- AssemblyItems{u256(0), u256(7), Instruction::RETURN},
- AssemblyItems{Instruction::STOP}
- );
-}
-
-BOOST_AUTO_TEST_CASE(control_flow_graph_remove_unused)
-{
- // remove parts of the code that are unused
- AssemblyItems input{
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- u256(7),
- AssemblyItem(Tag, 1),
- };
- checkCFG(input, {});
-}
-
-BOOST_AUTO_TEST_CASE(control_flow_graph_remove_unused_loop)
-{
- AssemblyItems input{
- AssemblyItem(PushTag, 3),
- Instruction::JUMP,
- AssemblyItem(Tag, 1),
- u256(7),
- AssemblyItem(PushTag, 2),
- Instruction::JUMP,
- AssemblyItem(Tag, 2),
- u256(8),
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- AssemblyItem(Tag, 3),
- u256(11)
- };
- checkCFG(input, {u256(11)});
-}
-
-BOOST_AUTO_TEST_CASE(control_flow_graph_reconnect_single_jump_source)
-{
- // move code that has only one unconditional jump source
- AssemblyItems input{
- u256(1),
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- AssemblyItem(Tag, 2),
- u256(2),
- AssemblyItem(PushTag, 3),
- Instruction::JUMP,
- AssemblyItem(Tag, 1),
- u256(3),
- AssemblyItem(PushTag, 2),
- Instruction::JUMP,
- AssemblyItem(Tag, 3),
- u256(4),
- };
- checkCFG(input, {u256(1), u256(3), u256(2), u256(4)});
-}
-
-BOOST_AUTO_TEST_CASE(control_flow_graph_do_not_remove_returned_to)
-{
- // do not remove parts that are "returned to"
- AssemblyItems input{
- AssemblyItem(PushTag, 1),
- AssemblyItem(PushTag, 2),
- Instruction::JUMP,
- AssemblyItem(Tag, 2),
- Instruction::JUMP,
- AssemblyItem(Tag, 1),
- u256(2)
- };
- checkCFG(input, {u256(2)});
-}
-
-BOOST_AUTO_TEST_CASE(block_deduplicator)
-{
- AssemblyItems input{
- AssemblyItem(PushTag, 2),
- AssemblyItem(PushTag, 1),
- AssemblyItem(PushTag, 3),
- u256(6),
- Instruction::SWAP3,
- Instruction::JUMP,
- AssemblyItem(Tag, 1),
- u256(6),
- Instruction::SWAP3,
- Instruction::JUMP,
- AssemblyItem(Tag, 2),
- u256(6),
- Instruction::SWAP3,
- Instruction::JUMP,
- AssemblyItem(Tag, 3)
- };
- BlockDeduplicator dedup(input);
- dedup.deduplicate();
-
- set<u256> pushTags;
- for (AssemblyItem const& item: input)
- if (item.type() == PushTag)
- pushTags.insert(item.data());
- BOOST_CHECK_EQUAL(pushTags.size(), 2);
-}
-
-BOOST_AUTO_TEST_CASE(block_deduplicator_loops)
-{
- AssemblyItems input{
- u256(0),
- Instruction::SLOAD,
- AssemblyItem(PushTag, 1),
- AssemblyItem(PushTag, 2),
- Instruction::JUMPI,
- Instruction::JUMP,
- AssemblyItem(Tag, 1),
- u256(5),
- u256(6),
- Instruction::SSTORE,
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- AssemblyItem(Tag, 2),
- u256(5),
- u256(6),
- Instruction::SSTORE,
- AssemblyItem(PushTag, 2),
- Instruction::JUMP,
- };
- BlockDeduplicator dedup(input);
- dedup.deduplicate();
-
- set<u256> pushTags;
- for (AssemblyItem const& item: input)
- if (item.type() == PushTag)
- pushTags.insert(item.data());
- BOOST_CHECK_EQUAL(pushTags.size(), 1);
-}
-
-BOOST_AUTO_TEST_CASE(clear_unreachable_code)
-{
- AssemblyItems items{
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- u256(0),
- Instruction::SLOAD,
- AssemblyItem(Tag, 2),
- u256(5),
- u256(6),
- Instruction::SSTORE,
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- u256(5),
- u256(6)
- };
- AssemblyItems expectation{
- AssemblyItem(PushTag, 1),
- Instruction::JUMP,
- AssemblyItem(Tag, 2),
- u256(5),
- u256(6),
- Instruction::SSTORE,
- AssemblyItem(PushTag, 1),
- Instruction::JUMP
- };
- PeepholeOptimiser peepOpt(items);
- BOOST_REQUIRE(peepOpt.optimise());
- BOOST_CHECK_EQUAL_COLLECTIONS(
- items.begin(), items.end(),
- expectation.begin(), expectation.end()
- );
-}
-
-BOOST_AUTO_TEST_CASE(peephole_double_push)
-{
- AssemblyItems items{
- u256(0),
- u256(0),
- u256(5),
- u256(5),
- u256(4),
- u256(5)
- };
- AssemblyItems expectation{
- u256(0),
- Instruction::DUP1,
- u256(5),
- Instruction::DUP1,
- u256(4),
- u256(5)
- };
- PeepholeOptimiser peepOpt(items);
- BOOST_REQUIRE(peepOpt.optimise());
- BOOST_CHECK_EQUAL_COLLECTIONS(
- items.begin(), items.end(),
- expectation.begin(), expectation.end()
- );
-}
-
BOOST_AUTO_TEST_CASE(computing_constants)
{
char const* sourceCode = R"(
@@ -1377,29 +581,6 @@ BOOST_AUTO_TEST_CASE(invalid_state_at_control_flow_join)
compareVersions("test()");
}
-BOOST_AUTO_TEST_CASE(cse_sub_zero)
-{
- checkCSE({
- u256(0),
- Instruction::DUP2,
- Instruction::SUB
- }, {
- Instruction::DUP1
- });
-
- checkCSE({
- Instruction::DUP1,
- u256(0),
- Instruction::SUB
- }, {
- u256(0),
- Instruction::DUP2,
- Instruction::SWAP1,
- Instruction::SUB
- });
-}
-
-
BOOST_AUTO_TEST_SUITE_END()
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-13 02:25:31 +0800