Merge pull request #2084 from chriseth/sol_computeConstants

Compute constants

libevmasm/Assembly.cpp

@@ -22,9 +22,12 @@
 #include "Assembly.h"
 #include <fstream>
 #include <libdevcore/Log.h>
+#include <libevmcore/Params.h>
 #include <libevmasm/CommonSubexpressionEliminator.h>
 #include <libevmasm/ControlFlowGraph.h>
 #include <libevmasm/BlockDeduplicator.h>
+#include <libevmasm/ConstantOptimiser.h>
+#include <libevmasm/GasMeter.h>
 #include <json/json.h>
 using namespace std;
 using namespace dev;
@@ -302,7 +305,7 @@ inline bool matches(AssemblyItemsConstRef _a, AssemblyItemsConstRef _b)
 struct OptimiserChannel: public LogChannel { static const char* name() { return "OPT"; } static const int verbosity = 12; };
 #define copt dev::LogOutputStream<OptimiserChannel, true>()
 
-Assembly& Assembly::optimise(bool _enable)
+Assembly& Assembly::optimise(bool _enable, bool _isCreation, size_t _runs)
 {
 	if (!_enable)
 		return *this;
@@ -364,10 +367,17 @@ Assembly& Assembly::optimise(bool _enable)
 		}
 	}
 
+	total += ConstantOptimisationMethod::optimiseConstants(
+		_isCreation,
+		_isCreation ? 1 : _runs,
+		*this,
+		m_items
+	);
+
 	copt << total << " optimisations done.";
 
 	for (auto& sub: m_subs)
-	  sub.optimise(true);
+	  sub.optimise(true, false, _runs);
 
 	return *this;
 }

libevmasm/Assembly.h

@@ -49,6 +49,7 @@ public:
 	AssemblyItem newPushTag() { return AssemblyItem(PushTag, m_usedTags++); }
 	AssemblyItem newData(bytes const& _data) { h256 h = (u256)std::hash<std::string>()(asString(_data)); m_data[h] = _data; return AssemblyItem(PushData, h); }
 	AssemblyItem newSub(Assembly const& _sub) { m_subs.push_back(_sub); return AssemblyItem(PushSub, m_subs.size() - 1); }
+	Assembly const& getSub(size_t _sub) const { return m_subs.at(_sub); }
 	AssemblyItem newPushString(std::string const& _data) { h256 h = (u256)std::hash<std::string>()(_data); m_strings[h] = _data; return AssemblyItem(PushString, h); }
 	AssemblyItem newPushSubSize(u256 const& _subId) { return AssemblyItem(PushSubSize, _subId); }
 
@@ -92,7 +93,13 @@ public:
 	void setSourceLocation(SourceLocation const& _location) { m_currentSourceLocation = _location; }
 
 	bytes assemble() const;
-	Assembly& optimise(bool _enable);
+	bytes const& data(h256 const& _i) const { return m_data[_i]; }
+
+	/// Modify (if @a _enable is set) and return the current assembly such that creation and
+	/// execution gas usage is optimised. @a _isCreation should be true for the top-level assembly.
+	/// @a _runs specifes an estimate on how often each opcode in this assembly will be executed,
+	/// i.e. use a small value to optimise for size and a large value to optimise for runtime.
+	Assembly& optimise(bool _enable, bool _isCreation = true, size_t _runs = 200);
 	Json::Value stream(
 		std::ostream& _out,
 		std::string const& _prefix = "",

libevmasm/ConstantOptimiser.cpp

@@ -0,0 +1,225 @@
+/*
+	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 ConstantOptimiser.cpp
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ */
+
+#include "libevmasm/ConstantOptimiser.h"
+#include <libevmasm/Assembly.h>
+#include <libevmasm/GasMeter.h>
+#include <libevmcore/Params.h>
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+unsigned ConstantOptimisationMethod::optimiseConstants(
+	bool _isCreation,
+	size_t _runs,
+	Assembly& _assembly,
+	AssemblyItems& _items
+)
+{
+	unsigned optimisations = 0;
+	map<AssemblyItem, size_t> pushes;
+	for (AssemblyItem const& item: _items)
+		if (item.type() == Push)
+			pushes[item]++;
+	for (auto it: pushes)
+	{
+		AssemblyItem const& item = it.first;
+		if (item.data() < 0x100)
+			continue;
+		Params params;
+		params.multiplicity = it.second;
+		params.isCreation = _isCreation;
+		params.runs = _runs;
+		LiteralMethod lit(params, item.data());
+		bigint literalGas = lit.gasNeeded();
+		CodeCopyMethod copy(params, item.data());
+		bigint copyGas = copy.gasNeeded();
+		ComputeMethod compute(params, item.data());
+		bigint computeGas = compute.gasNeeded();
+		if (copyGas < literalGas && copyGas < computeGas)
+		{
+			copy.execute(_assembly, _items);
+			optimisations++;
+		}
+		else if (computeGas < literalGas && computeGas < copyGas)
+		{
+			compute.execute(_assembly, _items);
+			optimisations++;
+		}
+	}
+	return optimisations;
+}
+
+bigint ConstantOptimisationMethod::simpleRunGas(AssemblyItems const& _items)
+{
+	bigint gas = 0;
+	for (AssemblyItem const& item: _items)
+		if (item.type() == Push)
+			gas += GasMeter::runGas(Instruction::PUSH1);
+		else if (item.type() == Operation)
+			gas += GasMeter::runGas(item.instruction());
+	return gas;
+}
+
+bigint ConstantOptimisationMethod::dataGas(bytes const& _data) const
+{
+	if (m_params.isCreation)
+	{
+		bigint gas;
+		for (auto b: _data)
+			gas += b ? c_txDataNonZeroGas : c_txDataZeroGas;
+		return gas;
+	}
+	else
+		return c_createDataGas * dataSize();
+}
+
+size_t ConstantOptimisationMethod::bytesRequired(AssemblyItems const& _items)
+{
+	size_t size = 0;
+	for (AssemblyItem const& item: _items)
+		size += item.bytesRequired(3); // assume 3 byte addresses
+	return size;
+}
+
+void ConstantOptimisationMethod::replaceConstants(
+	AssemblyItems& _items,
+	AssemblyItems const& _replacement
+) const
+{
+	assertThrow(_items.size() > 0, OptimizerException, "");
+	for (size_t i = 0; i < _items.size(); ++i)
+	{
+		if (_items.at(i) != AssemblyItem(m_value))
+			continue;
+		_items[i] = _replacement[0];
+		_items.insert(_items.begin() + i + 1, _replacement.begin() + 1, _replacement.end());
+		i += _replacement.size() - 1;
+	}
+}
+
+bigint LiteralMethod::gasNeeded()
+{
+	return combineGas(
+		simpleRunGas({Instruction::PUSH1}),
+		// PUSHX plus data
+		(m_params.isCreation ? c_txDataNonZeroGas : c_createDataGas) + dataGas(),
+		0
+	);
+}
+
+CodeCopyMethod::CodeCopyMethod(Params const& _params, u256 const& _value):
+	ConstantOptimisationMethod(_params, _value)
+{
+	m_copyRoutine = AssemblyItems{
+		u256(0),
+		Instruction::DUP1,
+		Instruction::MLOAD, // back up memory
+		u256(32),
+		AssemblyItem(PushData, u256(1) << 16), // has to be replaced
+		Instruction::DUP4,
+		Instruction::CODECOPY,
+		Instruction::DUP2,
+		Instruction::MLOAD,
+		Instruction::SWAP2,
+		Instruction::MSTORE
+	};
+}
+
+bigint CodeCopyMethod::gasNeeded()
+{
+	return combineGas(
+		// Run gas: we ignore memory increase costs
+		simpleRunGas(m_copyRoutine) + c_copyGas,
+		// Data gas for copy routines: Some bytes are zero, but we ignore them.
+		bytesRequired(m_copyRoutine) * (m_params.isCreation ? c_txDataNonZeroGas : c_createDataGas),
+		// Data gas for data itself
+		dataGas(toBigEndian(m_value))
+	);
+}
+
+void CodeCopyMethod::execute(Assembly& _assembly, AssemblyItems& _items)
+{
+	bytes data = toBigEndian(m_value);
+	m_copyRoutine[4] = _assembly.newData(data);
+	replaceConstants(_items, m_copyRoutine);
+}
+
+AssemblyItems ComputeMethod::findRepresentation(u256 const& _value)
+{
+	if (_value < 0x10000)
+		// Very small value, not worth computing
+		return AssemblyItems{_value};
+	else if (dev::bytesRequired(~_value) < dev::bytesRequired(_value))
+		// Negated is shorter to represent
+		return findRepresentation(~_value) + AssemblyItems{Instruction::NOT};
+	else
+	{
+		// Decompose value into a * 2**k + b where abs(b) << 2**k
+		// Is not always better, try literal and decomposition method.
+		AssemblyItems routine{u256(_value)};
+		bigint bestGas = gasNeeded(routine);
+		for (unsigned bits = 255; bits > 8; --bits)
+		{
+			unsigned gapDetector = unsigned(_value >> (bits - 8)) & 0x1ff;
+			if (gapDetector != 0xff && gapDetector != 0x100)
+				continue;
+
+			u256 powerOfTwo = u256(1) << bits;
+			u256 upperPart = _value >> bits;
+			bigint lowerPart = _value & (powerOfTwo - 1);
+			if (abs(powerOfTwo - lowerPart) < lowerPart)
+				lowerPart = lowerPart - powerOfTwo; // make it negative
+			if (abs(lowerPart) >= (powerOfTwo >> 8))
+				continue;
+
+			AssemblyItems newRoutine;
+			if (lowerPart != 0)
+				newRoutine += findRepresentation(u256(abs(lowerPart)));
+			newRoutine += AssemblyItems{u256(bits), u256(2), Instruction::EXP};
+			if (upperPart != 1 && upperPart != 0)
+				newRoutine += findRepresentation(upperPart) + AssemblyItems{Instruction::MUL};
+			if (lowerPart > 0)
+				newRoutine += AssemblyItems{Instruction::ADD};
+			else if (lowerPart < 0)
+				newRoutine.push_back(Instruction::SUB);
+
+			bigint newGas = gasNeeded(newRoutine);
+			if (newGas < bestGas)
+			{
+				bestGas = move(newGas);
+				routine = move(newRoutine);
+			}
+		}
+		return routine;
+	}
+}
+
+bigint ComputeMethod::gasNeeded(AssemblyItems const& _routine)
+{
+	size_t numExps = count(_routine.begin(), _routine.end(), Instruction::EXP);
+	return combineGas(
+		simpleRunGas(_routine) + numExps * (c_expGas + c_expByteGas),
+		// Data gas for routine: Some bytes are zero, but we ignore them.
+		bytesRequired(_routine) * (m_params.isCreation ? c_txDataNonZeroGas : c_createDataGas),
+		0
+	);
+}

libevmasm/ConstantOptimiser.h

@@ -0,0 +1,147 @@
+/*
+	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 ConstantOptimiser.cpp
+ * @author Christian <c@ethdev.com>
+ * @date 2015
+ */
+
+#pragma once
+
+#include <vector>
+#include <libdevcore/CommonData.h>
+#include <libdevcore/CommonIO.h>
+
+namespace dev
+{
+namespace eth
+{
+
+class AssemblyItem;
+using AssemblyItems = std::vector<AssemblyItem>;
+class Assembly;
+
+/**
+ * Abstract base class for one way to change how constants are represented in the code.
+ */
+class ConstantOptimisationMethod
+{
+public:
+	/// Tries to optimised how constants are represented in the source code and modifies
+	/// @a _assembly and its @a _items.
+	/// @returns zero if no optimisations could be performed.
+	static unsigned optimiseConstants(
+		bool _isCreation,
+		size_t _runs,
+		Assembly& _assembly,
+		AssemblyItems& _items
+	);
+
+	struct Params
+	{
+		bool isCreation; ///< Whether this is called during contract creation or runtime.
+		size_t runs; ///< Estimated number of calls per opcode oven the lifetime of the contract.
+		size_t multiplicity; ///< Number of times the constant appears in the code.
+	};
+
+	explicit ConstantOptimisationMethod(Params const& _params, u256 const& _value):
+		m_params(_params), m_value(_value) {}
+	virtual bigint gasNeeded() = 0;
+	virtual void execute(Assembly& _assembly, AssemblyItems& _items) = 0;
+
+protected:
+	size_t dataSize() const { return std::max<size_t>(1, dev::bytesRequired(m_value)); }
+
+	/// @returns the run gas for the given items ignoring special gas costs
+	static bigint simpleRunGas(AssemblyItems const& _items);
+	/// @returns the gas needed to store the given data literally
+	bigint dataGas(bytes const& _data) const;
+	/// @returns the gas needed to store the value literally
+	bigint dataGas() const { return dataGas(toCompactBigEndian(m_value, 1)); }
+	static size_t bytesRequired(AssemblyItems const& _items);
+	/// @returns the combined estimated gas usage taking @a m_params into account.
+	bigint combineGas(
+		bigint const& _runGas,
+		bigint const& _repeatedDataGas,
+		bigint const& _uniqueDataGas
+	)
+	{
+		// _runGas is not multiplied by _multiplicity because the runs are "per opcode"
+		return m_params.runs * _runGas + m_params.multiplicity * _repeatedDataGas + _uniqueDataGas;
+	}
+
+	/// Replaces the constant by the code given in @a _replacement.
+	void replaceConstants(AssemblyItems& _items, AssemblyItems const& _replacement) const;
+
+	Params m_params;
+	u256 const& m_value;
+};
+
+/**
+ * Optimisation method that pushes the constant to the stack literally. This is the default method,
+ * i.e. executing it does not alter the Assembly.
+ */
+class LiteralMethod: public ConstantOptimisationMethod
+{
+public:
+	explicit LiteralMethod(Params const& _params, u256 const& _value):
+		ConstantOptimisationMethod(_params, _value) {}
+	virtual bigint gasNeeded() override;
+	virtual void execute(Assembly&, AssemblyItems&) override {}
+};
+
+/**
+ * Method that stores the data in the .data section of the code and copies it to the stack.
+ */
+class CodeCopyMethod: public ConstantOptimisationMethod
+{
+public:
+	explicit CodeCopyMethod(Params const& _params, u256 const& _value);
+	virtual bigint gasNeeded() override;
+	virtual void execute(Assembly& _assembly, AssemblyItems& _items) override;
+
+protected:
+	AssemblyItems m_copyRoutine;
+};
+
+/**
+ * Method that tries to compute the constant.
+ */
+class ComputeMethod: public ConstantOptimisationMethod
+{
+public:
+	explicit ComputeMethod(Params const& _params, u256 const& _value):
+		ConstantOptimisationMethod(_params, _value)
+	{
+		m_routine = findRepresentation(m_value);
+	}
+
+	virtual bigint gasNeeded() override { return gasNeeded(m_routine); }
+	virtual void execute(Assembly&, AssemblyItems& _items) override
+	{
+		replaceConstants(_items, m_routine);
+	}
+
+protected:
+	/// Tries to recursively find a way to compute @a _value.
+	AssemblyItems findRepresentation(u256 const& _value);
+	bigint gasNeeded(AssemblyItems const& _routine);
+
+	AssemblyItems m_routine;
+};
+
+}
+}

libevmasm/GasMeter.cpp

@@ -201,13 +201,14 @@ GasMeter::GasConsumption GasMeter::memoryGas(int _stackPosOffset, int _stackPosS
 		}));
 }
 
-GasMeter::GasConsumption GasMeter::runGas(Instruction _instruction)
+u256 GasMeter::runGas(Instruction _instruction)
 {
 	if (_instruction == Instruction::JUMPDEST)
-		return GasConsumption(1);
+		return 1;
 
 	int tier = instructionInfo(_instruction).gasPriceTier;
-	return tier == InvalidTier ? GasConsumption::infinite() : c_tierStepGas[tier];
+	assertThrow(tier != InvalidTier, OptimizerException, "Invalid gas tier.");
+	return c_tierStepGas[tier];
 }
 
 

libevmasm/GasMeter.h

@@ -66,6 +66,8 @@ public:
 
 	u256 const& largestMemoryAccess() const { return m_largestMemoryAccess; }
 
+	static u256 runGas(Instruction _instruction);
+
 private:
 	/// @returns _multiplier * (_value + 31) / 32, if _value is a known constant and infinite otherwise.
 	GasConsumption wordGas(u256 const& _multiplier, ExpressionClasses::Id _value);
@@ -76,8 +78,6 @@ private:
 	/// given as values on the stack at the given relative positions.
 	GasConsumption memoryGas(int _stackPosOffset, int _stackPosSize);
 
-	static GasConsumption runGas(Instruction _instruction);
-
 	std::shared_ptr<KnownState> m_state;
 	/// Largest point where memory was accessed since the creation of this object.
 	u256 m_largestMemoryAccess;

libevmcore/Instruction.cpp

@@ -300,7 +300,7 @@ void dev::eth::eachInstruction(
 	function<void(Instruction,u256 const&)> const& _onInstruction
 )
 {
-	for (auto it = _mem.begin(); it != _mem.end(); ++it)
+	for (auto it = _mem.begin(); it < _mem.end(); ++it)
 	{
 		Instruction instr = Instruction(*it);
 		size_t additional = 0;
@@ -310,7 +310,7 @@ void dev::eth::eachInstruction(
 		for (size_t i = 0; i < additional; ++i)
 		{
 			data <<= 8;
-			if (it != _mem.end() && ++it != _mem.end())
+			if (++it < _mem.end())
 				data |= *it;
 		}
 		_onInstruction(instr, data);

libsolidity/Compiler.cpp

@@ -69,6 +69,8 @@ void Compiler::compileContract(ContractDefinition const& _contract,
 	swap(m_context, m_runtimeContext);
 	initializeContext(_contract, _contracts);
 	packIntoContractCreator(_contract, m_runtimeContext);
+	if (m_optimize)
+		m_context.optimise(m_optimizeRuns);
 }
 
 eth::AssemblyItem Compiler::getFunctionEntryLabel(FunctionDefinition const& _function) const
@@ -120,9 +122,11 @@ void Compiler::packIntoContractCreator(ContractDefinition const& _contract, Comp
 	else if (auto c = m_context.getNextConstructor(_contract))
 		appendBaseConstructor(*c);
 
-	eth::AssemblyItem sub = m_context.addSubroutine(_runtimeContext.getAssembly());
+	eth::AssemblyItem runtimeSub = m_context.addSubroutine(_runtimeContext.getAssembly());
+	solAssert(runtimeSub.data() < numeric_limits<size_t>::max(), "");
+	m_runtimeSub = size_t(runtimeSub.data());
 	// stack contains sub size
-	m_context << eth::Instruction::DUP1 << sub << u256(0) << eth::Instruction::CODECOPY;
+	m_context << eth::Instruction::DUP1 << runtimeSub << u256(0) << eth::Instruction::CODECOPY;
 	m_context << u256(0) << eth::Instruction::RETURN;
 
 	// note that we have to include the functions again because of absolute jump labels

libsolidity/Compiler.h

@@ -34,13 +34,18 @@ namespace solidity {
 class Compiler: private ASTConstVisitor
 {
 public:
-	explicit Compiler(bool _optimize = false): m_optimize(_optimize), m_context(),
-		m_returnTag(m_context.newTag()) {}
+	explicit Compiler(bool _optimize = false, unsigned _runs = 200):
+		m_optimize(_optimize),
+		m_optimizeRuns(_runs),
+		m_context(),
+		m_returnTag(m_context.newTag())
+	{
+	}
 
 	void compileContract(ContractDefinition const& _contract,
 						 std::map<ContractDefinition const*, bytes const*> const& _contracts);
-	bytes getAssembledBytecode() { return m_context.getAssembledBytecode(m_optimize); }
-	bytes getRuntimeBytecode() { return m_runtimeContext.getAssembledBytecode(m_optimize);}
+	bytes getAssembledBytecode() { return m_context.getAssembledBytecode(); }
+	bytes getRuntimeBytecode() { return m_context.getAssembledRuntimeBytecode(m_runtimeSub); }
 	/// @arg _sourceCodes is the map of input files to source code strings
 	/// @arg _inJsonFromat shows whether the out should be in Json format
 	Json::Value streamAssembly(std::ostream& _stream, StringMap const& _sourceCodes = StringMap(), bool _inJsonFormat = false) const
@@ -50,7 +55,7 @@ public:
 	/// @returns Assembly items of the normal compiler context
 	eth::AssemblyItems const& getAssemblyItems() const { return m_context.getAssembly().getItems(); }
 	/// @returns Assembly items of the runtime compiler context
-	eth::AssemblyItems const& getRuntimeAssemblyItems() const { return m_runtimeContext.getAssembly().getItems(); }
+	eth::AssemblyItems const& getRuntimeAssemblyItems() const { return m_context.getAssembly().getSub(m_runtimeSub).getItems(); }
 
 	/// @returns the entry label of the given function. Might return an AssemblyItem of type
 	/// UndefinedItem if it does not exist yet.
@@ -93,7 +98,9 @@ private:
 	void compileExpression(Expression const& _expression, TypePointer const& _targetType = TypePointer());
 
 	bool const m_optimize;
+	unsigned const m_optimizeRuns;
 	CompilerContext m_context;
+	size_t m_runtimeSub = size_t(-1); ///< Identifier of the runtime sub-assembly
 	CompilerContext m_runtimeContext;
 	std::vector<eth::AssemblyItem> m_breakTags; ///< tag to jump to for a "break" statement
 	std::vector<eth::AssemblyItem> m_continueTags; ///< tag to jump to for a "continue" statement

libsolidity/CompilerContext.h

@@ -126,6 +126,8 @@ public:
 	CompilerContext& operator<<(u256 const& _value) { m_asm.append(_value); return *this; }
 	CompilerContext& operator<<(bytes const& _data) { m_asm.append(_data); return *this; }
 
+	void optimise(unsigned _runs = 200) { m_asm.optimise(true, true, _runs); }
+
 	eth::Assembly const& getAssembly() const { return m_asm; }
 	/// @arg _sourceCodes is the map of input files to source code strings
 	/// @arg _inJsonFormat shows whether the out should be in Json format
@@ -134,7 +136,8 @@ public:
 		return m_asm.stream(_stream, "", _sourceCodes, _inJsonFormat);
 	}
 
-	bytes getAssembledBytecode(bool _optimize = false) { return m_asm.optimise(_optimize).assemble(); }
+	bytes getAssembledBytecode() { return m_asm.assemble(); }
+	bytes getAssembledRuntimeBytecode(size_t _subIndex) { m_asm.assemble(); return m_asm.data(u256(_subIndex)); }
 
 	/**
 	 * Helper class to pop the visited nodes stack when a scope closes

libsolidity/CompilerStack.cpp

@@ -145,7 +145,7 @@ vector<string> CompilerStack::getContractNames() const
 }
 
 
-void CompilerStack::compile(bool _optimize)
+void CompilerStack::compile(bool _optimize, unsigned _runs)
 {
 	if (!m_parseSuccessful)
 		parse();
@@ -157,9 +157,9 @@ void CompilerStack::compile(bool _optimize)
 			{
 				if (!contract->isFullyImplemented())
 					continue;
-				shared_ptr<Compiler> compiler = make_shared<Compiler>(_optimize);
+				shared_ptr<Compiler> compiler = make_shared<Compiler>(_optimize, _runs);
 				compiler->compileContract(*contract, contractBytecode);
-				Contract& compiledContract = m_contracts[contract->getName()];
+				Contract& compiledContract = m_contracts.at(contract->getName());
 				compiledContract.bytecode = compiler->getAssembledBytecode();
 				compiledContract.runtimeBytecode = compiler->getRuntimeBytecode();
 				compiledContract.compiler = move(compiler);

libsolidity/CompilerStack.h

@@ -90,7 +90,7 @@ public:
 	std::string defaultContractName() const;
 
 	/// Compiles the source units that were previously added and parsed.
-	void compile(bool _optimize = false);
+	void compile(bool _optimize = false, unsigned _runs = 200);
 	/// Parses and compiles the given source code.
 	/// @returns the compiled bytecode
 	bytes const& compile(std::string const& _sourceCode, bool _optimize = false);

solc/CommandLineInterface.cpp

@@ -299,7 +299,8 @@ bool CommandLineInterface::parseArguments(int argc, char** argv)
 	desc.add_options()
 		("help", "Show help message and exit")
 		("version", "Show version and exit")
-		("optimize", po::value<bool>()->default_value(false), "Optimize bytecode for size")
+		("optimize", po::value<bool>()->default_value(false), "Optimize bytecode")
+		("optimize-runs", po::value<unsigned>()->default_value(200), "Estimated number of contract runs for optimizer.")
 		("add-std", po::value<bool>()->default_value(false), "Add standard contracts")
 		("input-file", po::value<vector<string>>(), "input file")
 		(
@@ -409,7 +410,11 @@ bool CommandLineInterface::processInput()
 		for (auto const& sourceCode: m_sourceCodes)
 			m_compiler->addSource(sourceCode.first, sourceCode.second);
 		// TODO: Perhaps we should not compile unless requested
-		m_compiler->compile(m_args["optimize"].as<bool>());
+		bool optimize = m_args["optimize"].as<bool>();
+		unsigned runs = m_args["optimize-runs"].as<unsigned>();
+		if (m_args.count("optimize-runs"))
+			optimize = true;
+		m_compiler->compile(optimize, runs);
 	}
 	catch (ParserError const& _exception)
 	{

test/libsolidity/SolidityOptimizer.cpp

@@ -1036,6 +1036,51 @@ BOOST_AUTO_TEST_CASE(block_deduplicator_loops)
 	BOOST_CHECK_EQUAL(pushTags.size(), 1);
 }
 
+BOOST_AUTO_TEST_CASE(computing_constants)
+{
+	char const* sourceCode = R"(
+		contract c {
+			uint a;
+			uint b;
+			uint c;
+			function set() returns (uint a, uint b, uint c) {
+				a = 0x77abc0000000000000000000000000000000000000000000000000000000001;
+				b = 0x817416927846239487123469187231298734162934871263941234127518276;
+				g();
+			}
+			function g() {
+				b = 0x817416927846239487123469187231298734162934871263941234127518276;
+				c = 0x817416927846239487123469187231298734162934871263941234127518276;
+			}
+			function get() returns (uint ra, uint rb, uint rc) {
+				ra = a;
+				rb = b;
+				rc = c ;
+			}
+		}
+	)";
+	compileBothVersions(sourceCode);
+	compareVersions("set()");
+	compareVersions("get()");
+
+	m_optimize = true;
+	m_optimizeRuns = 1;
+	bytes optimizedBytecode = compileAndRun(sourceCode, 0, "c");
+	bytes complicatedConstant = toBigEndian(u256("0x817416927846239487123469187231298734162934871263941234127518276"));
+	unsigned occurrences = 0;
+	for (auto iter = optimizedBytecode.cbegin(); iter < optimizedBytecode.cend(); ++occurrences)
+		iter = search(iter, optimizedBytecode.cend(), complicatedConstant.cbegin(), complicatedConstant.cend()) + 1;
+	BOOST_CHECK_EQUAL(2, occurrences);
+
+	bytes constantWithZeros = toBigEndian(u256("0x77abc0000000000000000000000000000000000000000000000000000000001"));
+	BOOST_CHECK(search(
+		optimizedBytecode.cbegin(),
+		optimizedBytecode.cend(),
+		constantWithZeros.cbegin(),
+		constantWithZeros.cend()
+	) == optimizedBytecode.cend());
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/libsolidity/solidityExecutionFramework.h

@@ -46,7 +46,7 @@ public:
 	{
 		m_compiler.reset(false, m_addStandardSources);
 		m_compiler.addSource("", _sourceCode);
-		ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize), "Compiling contract failed");
+		ETH_TEST_REQUIRE_NO_THROW(m_compiler.compile(m_optimize, m_optimizeRuns), "Compiling contract failed");
 		bytes code = m_compiler.getBytecode(_contractName);
 		sendMessage(code, true, _value);
 		return m_output;
@@ -180,6 +180,7 @@ protected:
 		m_logs = executive.logs();
 	}
 
+	size_t m_optimizeRuns = 200;
 	bool m_optimize = false;
 	bool m_addStandardSources = false;
 	dev::solidity::CompilerStack m_compiler;