Functional gas estimator.

libevmasm/ExpressionClasses.cpp

@@ -57,11 +57,11 @@ ExpressionClasses::Id ExpressionClasses::find(
 	exp.arguments = _arguments;
 	exp.sequenceNumber = _sequenceNumber;
 
+	if (SemanticInformation::isCommutativeOperation(_item))
+		sort(exp.arguments.begin(), exp.arguments.end());
+
 	if (SemanticInformation::isDeterministic(_item))
 	{
-		if (SemanticInformation::isCommutativeOperation(_item))
-			sort(exp.arguments.begin(), exp.arguments.end());
-
 		auto it = m_expressions.find(exp);
 		if (it != m_expressions.end())
 			return it->id;
@@ -82,6 +82,27 @@ ExpressionClasses::Id ExpressionClasses::find(
 	return exp.id;
 }
 
+void ExpressionClasses::forceEqual(
+	ExpressionClasses::Id _id,
+	AssemblyItem const& _item,
+	ExpressionClasses::Ids const& _arguments,
+	bool _copyItem
+)
+{
+	Expression exp;
+	exp.id = _id;
+	exp.item = &_item;
+	exp.arguments = _arguments;
+
+	if (SemanticInformation::isCommutativeOperation(_item))
+		sort(exp.arguments.begin(), exp.arguments.end());
+
+	if (_copyItem)
+		exp.item = storeItem(_item);
+
+	m_expressions.insert(exp);
+}
+
 ExpressionClasses::Id ExpressionClasses::newClass(SourceLocation const& _location)
 {
 	Expression exp;

libevmasm/ExpressionClasses.h

@@ -74,6 +74,11 @@ public:
 	/// @returns the number of classes.
 	Id size() const { return m_representatives.size(); }
 
+	/// Forces the given @a _item with @a _arguments to the class @a _id. This can be used to
+	/// add prior knowledge e.g. about CALLDATA, but has to be used with caution. Will not work as
+	/// expected if @a _item applied to @a _arguments already exists.
+	void forceEqual(Id _id, AssemblyItem const& _item, Ids const& _arguments, bool _copyItem = true);
+
 	/// @returns the id of a new class which is different to all other classes.
 	Id newClass(SourceLocation const& _location);
 

libsolidity/ASTPrinter.cpp

@@ -33,7 +33,7 @@ namespace solidity
 ASTPrinter::ASTPrinter(
 	ASTNode const& _ast,
 	string const& _source,
-	StructuralGasEstimator::ASTGasConsumption const& _gasCosts
+	GasEstimator::ASTGasConsumption const& _gasCosts
 ): m_indentation(0), m_source(_source), m_ast(&_ast), m_gasCosts(_gasCosts)
 {
 }

libsolidity/ASTPrinter.h

@@ -24,7 +24,7 @@
 
 #include <ostream>
 #include <libsolidity/ASTVisitor.h>
-#include <libsolidity/StructuralGasEstimator.h>
+#include <libsolidity/GasEstimator.h>
 
 namespace dev
 {
@@ -42,7 +42,7 @@ public:
 	ASTPrinter(
 		ASTNode const& _ast,
 		std::string const& _source = std::string(),
-		StructuralGasEstimator::ASTGasConsumption const& _gasCosts = StructuralGasEstimator::ASTGasConsumption()
+		GasEstimator::ASTGasConsumption const& _gasCosts = GasEstimator::ASTGasConsumption()
 	);
 	/// Output the string representation of the AST to _stream.
 	void print(std::ostream& _stream);
@@ -133,7 +133,7 @@ private:
 	int m_indentation;
 	std::string m_source;
 	ASTNode const* m_ast;
-	StructuralGasEstimator::ASTGasConsumption m_gasCosts;
+	GasEstimator::ASTGasConsumption m_gasCosts;
 	std::ostream* m_ostream;
 };
 

libsolidity/StructuralGasEstimator.cpp → libsolidity/GasEstimator.cpp

@@ -20,12 +20,14 @@
  * Gas consumption estimator working alongside the AST.
  */
 
-#include "StructuralGasEstimator.h"
+#include "GasEstimator.h"
 #include <map>
 #include <functional>
 #include <memory>
+#include <libdevcore/SHA3.h>
 #include <libevmasm/ControlFlowGraph.h>
 #include <libevmasm/KnownState.h>
+#include <libevmasm/PathGasMeter.h>
 #include <libsolidity/AST.h>
 #include <libsolidity/ASTVisitor.h>
 
@@ -34,13 +36,13 @@ using namespace dev;
 using namespace dev::eth;
 using namespace dev::solidity;
 
-StructuralGasEstimator::ASTGasConsumptionSelfAccumulated StructuralGasEstimator::performEstimation(
+GasEstimator::ASTGasConsumptionSelfAccumulated GasEstimator::structuralEstimation(
 	AssemblyItems const& _items,
 	vector<ASTNode const*> const& _ast
 )
 {
 	solAssert(std::count(_ast.begin(), _ast.end(), nullptr) == 0, "");
-	map<SourceLocation, GasMeter::GasConsumption> particularCosts;
+	map<SourceLocation, GasConsumption> particularCosts;
 
 	ControlFlowGraph cfg(_items);
 	for (BasicBlock const& block: cfg.optimisedBlocks())
@@ -72,7 +74,7 @@ StructuralGasEstimator::ASTGasConsumptionSelfAccumulated StructuralGasEstimator:
 	return gasCosts;
 }
 
-map<ASTNode const*, GasMeter::GasConsumption> StructuralGasEstimator::breakToStatementLevel(
+map<ASTNode const*, GasMeter::GasConsumption> GasEstimator::breakToStatementLevel(
 	ASTGasConsumptionSelfAccumulated const& _gasCosts,
 	vector<ASTNode const*> const& _roots
 )
@@ -99,7 +101,7 @@ map<ASTNode const*, GasMeter::GasConsumption> StructuralGasEstimator::breakToSta
 	// we use the location of a node if
 	//  - its statement depth is 0 or
 	//  - its statement depth is undefined but the parent's statement depth is at least 1
-	map<ASTNode const*, GasMeter::GasConsumption> gasCosts;
+	map<ASTNode const*, GasConsumption> gasCosts;
 	auto onNodeSecondPass = [&](ASTNode const& _node)
 	{
 		return statementDepth.count(&_node);
@@ -121,7 +123,28 @@ map<ASTNode const*, GasMeter::GasConsumption> StructuralGasEstimator::breakToSta
 	return gasCosts;
 }
 
-set<ASTNode const*> StructuralGasEstimator::finestNodesAtLocation(
+GasEstimator::GasConsumption GasEstimator::functionalEstimation(
+	AssemblyItems const& _items,
+	string const& _signature
+)
+{
+	auto state = make_shared<KnownState>();
+
+	ExpressionClasses& classes = state->expressionClasses();
+	using Id = ExpressionClasses::Id;
+	using Ids = vector<Id>;
+	Id hashValue = classes.find(u256(FixedHash<4>::Arith(FixedHash<4>(dev::sha3(_signature)))));
+	Id calldata = classes.find(eth::Instruction::CALLDATALOAD, Ids{classes.find(u256(0))});
+	classes.forceEqual(hashValue, eth::Instruction::DIV, Ids{
+		calldata,
+		classes.find(u256(1) << (8 * 28))
+	});
+
+	PathGasMeter meter(_items);
+	return meter.estimateMax(0, state);
+}
+
+set<ASTNode const*> GasEstimator::finestNodesAtLocation(
 	vector<ASTNode const*> const& _roots
 )
 {
@@ -140,4 +163,3 @@ set<ASTNode const*> StructuralGasEstimator::finestNodesAtLocation(
 		root->accept(visitor);
 	return nodes;
 }
-

libsolidity/StructuralGasEstimator.h → libsolidity/GasEstimator.h

@@ -34,17 +34,18 @@ namespace dev
 namespace solidity
 {
 
-class StructuralGasEstimator
+struct GasEstimator
 {
 public:
-	using ASTGasConsumption = std::map<ASTNode const*, eth::GasMeter::GasConsumption>;
+	using GasConsumption = eth::GasMeter::GasConsumption;
+	using ASTGasConsumption = std::map<ASTNode const*, GasConsumption>;
 	using ASTGasConsumptionSelfAccumulated =
-		std::map<ASTNode const*, std::array<eth::GasMeter::GasConsumption, 2>>;
+		std::map<ASTNode const*, std::array<GasConsumption, 2>>;
 
 	/// Estimates the gas consumption for every assembly item in the given assembly and stores
 	/// it by source location.
 	/// @returns a mapping from each AST node to a pair of its particular and syntactically accumulated gas costs.
-	ASTGasConsumptionSelfAccumulated performEstimation(
+	static ASTGasConsumptionSelfAccumulated structuralEstimation(
 		eth::AssemblyItems const& _items,
 		std::vector<ASTNode const*> const& _ast
 	);
@@ -52,14 +53,21 @@ public:
 	/// the following source locations are part of the mapping:
 	/// 1. source locations of statements that do not contain other statements
 	/// 2. maximal source locations that do not overlap locations coming from the first rule
-	ASTGasConsumption breakToStatementLevel(
+	static ASTGasConsumption breakToStatementLevel(
 		ASTGasConsumptionSelfAccumulated const& _gasCosts,
 		std::vector<ASTNode const*> const& _roots
 	);
 
+	/// @returns the estimated gas consumption by the (public or external) function with the
+	/// given signature. If no signature is given, estimates the maximum gas usage.
+	static GasConsumption functionalEstimation(
+		eth::AssemblyItems const& _items,
+		std::string const& _signature = ""
+	);
+
 private:
 	/// @returns the set of AST nodes which are the finest nodes at their location.
-	std::set<ASTNode const*> finestNodesAtLocation(std::vector<ASTNode const*> const& _roots);
+	static std::set<ASTNode const*> finestNodesAtLocation(std::vector<ASTNode const*> const& _roots);
 };
 
 }

mix/CodeModel.cpp

@@ -33,7 +33,7 @@
 #include <libsolidity/CompilerStack.h>
 #include <libsolidity/SourceReferenceFormatter.h>
 #include <libsolidity/InterfaceHandler.h>
-#include <libsolidity/StructuralGasEstimator.h>
+#include <libsolidity/GasEstimator.h>
 #include <libsolidity/SourceReferenceFormatter.h>
 #include <libevmcore/Instruction.h>
 #include <libethcore/CommonJS.h>
@@ -371,8 +371,7 @@ void CodeModel::gasEstimation(solidity::CompilerStack const& _cs)
 			continue;
 		dev::solidity::SourceUnit const& sourceUnit = _cs.getAST(*contractDefinition.getLocation().sourceName);
 		AssemblyItems const* items = _cs.getRuntimeAssemblyItems(n);
-		StructuralGasEstimator estimator;
+		std::map<ASTNode const*, GasMeter::GasConsumption> gasCosts = GasEstimator::breakToStatementLevel(GasEstimator::structuralEstimation(*items, std::vector<ASTNode const*>({&sourceUnit})), {&sourceUnit});
-		std::map<ASTNode const*, GasMeter::GasConsumption> gasCosts = estimator.breakToStatementLevel(estimator.performEstimation(*items, std::vector<ASTNode const*>({&sourceUnit})), {&sourceUnit});
 		for (auto gasItem = gasCosts.begin(); gasItem != gasCosts.end(); ++gasItem)
 		{
 			SourceLocation const& location = gasItem->first->getLocation();

solc/CommandLineInterface.cpp

@@ -42,7 +42,7 @@
 #include <libsolidity/Exceptions.h>
 #include <libsolidity/CompilerStack.h>
 #include <libsolidity/SourceReferenceFormatter.h>
-#include <libsolidity/StructuralGasEstimator.h>
+#include <libsolidity/GasEstimator.h>
 
 using namespace std;
 namespace po = boost::program_options;
@@ -465,14 +465,13 @@ void CommandLineInterface::handleAst(string const& _argStr)
 	// do we need AST output?
 	if (m_args.count(_argStr))
 	{
-		StructuralGasEstimator gasEstimator;
 		vector<ASTNode const*> asts;
 		for (auto const& sourceCode: m_sourceCodes)
 			asts.push_back(&m_compiler->getAST(sourceCode.first));
 		map<ASTNode const*, eth::GasMeter::GasConsumption> gasCosts;
 		if (m_compiler->getRuntimeAssemblyItems())
-			gasCosts = gasEstimator.breakToStatementLevel(
+			gasCosts = GasEstimator::breakToStatementLevel(
-				gasEstimator.performEstimation(*m_compiler->getRuntimeAssemblyItems(), asts),
+				GasEstimator::structuralEstimation(*m_compiler->getRuntimeAssemblyItems(), asts),
 				asts
 			);
 

test/libsolidity/GasMeter.cpp

@@ -25,7 +25,7 @@
 #include <libevmasm/KnownState.h>
 #include <libevmasm/PathGasMeter.h>
 #include <libsolidity/AST.h>
-#include <libsolidity/StructuralGasEstimator.h>
+#include <libsolidity/GasEstimator.h>
 #include <libsolidity/SourceReferenceFormatter.h>
 
 using namespace std;
@@ -48,12 +48,11 @@ public:
 		m_compiler.setSource(_sourceCode);
 		ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(), "Compiling contract failed");
 
-		StructuralGasEstimator estimator;
 		AssemblyItems const* items = m_compiler.getRuntimeAssemblyItems("");
 		ASTNode const& sourceUnit = m_compiler.getAST();
 		BOOST_REQUIRE(items != nullptr);
-		m_gasCosts = estimator.breakToStatementLevel(
+		m_gasCosts = GasEstimator::breakToStatementLevel(
-			estimator.performEstimation(*items, vector<ASTNode const*>({&sourceUnit})),
+			GasEstimator::structuralEstimation(*items, vector<ASTNode const*>({&sourceUnit})),
 			{&sourceUnit}
 		);
 	}
@@ -70,6 +69,8 @@ public:
 		BOOST_CHECK(gas.value == m_gasUsed);
 	}
 
+	/// Compares the gas computed by PathGasMeter for the given signature (but unknown arguments)
+	/// against the actual gas usage computed by the VM on the given set of argument variants.
 	void testRunTimeGas(std::string const& _sig, vector<bytes> _argumentVariants)
 	{
 		u256 gasUsed = 0;
@@ -80,12 +81,10 @@ public:
 			gasUsed = max(gasUsed, m_gasUsed);
 		}
 
-		auto state = make_shared<KnownState>();
+		GasMeter::GasConsumption gas = GasEstimator::functionalEstimation(
-		//TODO modify state to include function hash in calldata
+			*m_compiler.getRuntimeAssemblyItems(),
-		PathGasMeter meter(*m_compiler.getRuntimeAssemblyItems());
+			_sig
-		GasMeter::GasConsumption gas = meter.estimateMax(0, state);
+		);
-		cout << "VM: " << gasUsed << endl;
-		cout << "est: " << gas << endl;
 		BOOST_REQUIRE(!gas.isInfinite);
 		BOOST_CHECK(gas.value == m_gasUsed);
 	}
@@ -207,6 +206,28 @@ BOOST_AUTO_TEST_CASE(function_calls)
 	testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2), encodeArgs(8)});
 }
 
+BOOST_AUTO_TEST_CASE(multiple_external_functions)
+{
+	char const* sourceCode = R"(
+		contract test {
+			uint data;
+			uint data2;
+			function f(uint x) {
+				if (x > 7)
+					data2 = g(x**8) + 1;
+				else
+					data = 1;
+			}
+			function g(uint x) returns (uint) {
+				return data2;
+			}
+		}
+	)";
+	testCreationTimeGas(sourceCode);
+	testRunTimeGas("f(uint256)", vector<bytes>{encodeArgs(2), encodeArgs(8)});
+	testRunTimeGas("g(uint256)", vector<bytes>{encodeArgs(2)});
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }