Changes in compiler to support variably sized stack elements.

libsolidity/Compiler.cpp

@@ -26,6 +26,7 @@
 #include <libsolidity/AST.h>
 #include <libsolidity/Compiler.h>
 #include <libsolidity/ExpressionCompiler.h>
+#include <libsolidity/CompilerUtils.h>
 
 using namespace std;
 
@@ -135,7 +136,7 @@ unsigned Compiler::appendCalldataUnpacker(FunctionDefinition const& _function, b
 	for (ASTPointer<VariableDeclaration> const& var: _function.getParameters())
 	{
 		unsigned const numBytes = var->getType()->getCalldataEncodedSize();
-		if (numBytes == 0)
+		if (numBytes == 0 || numBytes > 32)
 			BOOST_THROW_EXCEPTION(CompilerError()
 								  << errinfo_sourceLocation(var->getLocation())
 								  << errinfo_comment("Type " + var->getType()->toString() + " not yet supported."));
@@ -158,7 +159,7 @@ void Compiler::appendReturnValuePacker(FunctionDefinition const& _function)
 	{
 		Type const& paramType = *parameters[i]->getType();
 		unsigned numBytes = paramType.getCalldataEncodedSize();
-		if (numBytes == 0)
+		if (numBytes == 0 || numBytes > 32)
 			BOOST_THROW_EXCEPTION(CompilerError()
 								  << errinfo_sourceLocation(parameters[i]->getLocation())
 								  << errinfo_comment("Type " + paramType.toString() + " not yet supported."));
@@ -305,8 +306,7 @@ bool Compiler::visit(Return& _return)
 		VariableDeclaration const& firstVariable = *_return.getFunctionReturnParameters().getParameters().front();
 		ExpressionCompiler::appendTypeConversion(m_context, *expression->getType(), *firstVariable.getType());
 
-		unsigned stackPosition = m_context.baseToCurrentStackOffset(m_context.getBaseStackOffsetOfVariable(firstVariable));
+		CompilerUtils(m_context).moveToStackVariable(firstVariable);
-		m_context << eth::swapInstruction(stackPosition) << eth::Instruction::POP;
 	}
 	m_context.appendJumpTo(m_returnTag);
 	return false;
@@ -320,9 +320,7 @@ bool Compiler::visit(VariableDefinition& _variableDefinition)
 		ExpressionCompiler::appendTypeConversion(m_context,
 												 *expression->getType(),
 												 *_variableDefinition.getDeclaration().getType());
-		unsigned baseStackOffset = m_context.getBaseStackOffsetOfVariable(_variableDefinition.getDeclaration());
+		CompilerUtils(m_context).moveToStackVariable(_variableDefinition.getDeclaration());
-		unsigned stackPosition = m_context.baseToCurrentStackOffset(baseStackOffset);
-		m_context << eth::swapInstruction(stackPosition) << eth::Instruction::POP;
 	}
 	return false;
 }
@@ -331,9 +329,7 @@ bool Compiler::visit(ExpressionStatement& _expressionStatement)
 {
 	Expression& expression = _expressionStatement.getExpression();
 	ExpressionCompiler::compileExpression(m_context, expression);
-//	Type::Category category = expression.getType()->getCategory();
+	CompilerUtils(m_context).popStackElement(*expression.getType());
-	for (unsigned i = 0; i < expression.getType()->getSizeOnStack(); ++i)
-		m_context << eth::Instruction::POP;
 	return false;
 }
 

libsolidity/CompilerContext.cpp

@@ -57,6 +57,11 @@ void CompilerContext::addAndInitializeVariable(VariableDeclaration const& _decla
 	m_asm.adjustDeposit(-size);
 }
 
+void CompilerContext::addFunction(FunctionDefinition const& _function)
+{
+	m_functionEntryLabels.insert(std::make_pair(&_function, m_asm.newTag()));
+}
+
 bool CompilerContext::isLocalVariable(Declaration const* _declaration) const
 {
 	return m_localVariables.count(_declaration) > 0;

libsolidity/CompilerContext.h

@@ -25,6 +25,7 @@
 #include <ostream>
 #include <libevmcore/Instruction.h>
 #include <libevmcore/Assembly.h>
+#include <libsolidity/ASTForward.h>
 #include <libsolidity/Types.h>
 
 namespace dev {
@@ -45,7 +46,7 @@ public:
 	void startNewFunction() { m_localVariables.clear(); m_asm.setDeposit(0); }
 	void addVariable(VariableDeclaration const& _declaration);
 	void addAndInitializeVariable(VariableDeclaration const& _declaration);
-	void addFunction(FunctionDefinition const& _function) { m_functionEntryLabels.insert(std::make_pair(&_function, m_asm.newTag())); }
+	void addFunction(FunctionDefinition const& _function);
 
 	void adjustStackOffset(int _adjustment) { m_asm.adjustDeposit(_adjustment); }
 

libsolidity/CompilerUtils.cpp

@@ -0,0 +1,50 @@
+/*
+	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/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Routines used by both the compiler and the expression compiler.
+ */
+
+#include <libsolidity/CompilerUtils.h>
+#include <libsolidity/AST.h>
+#include <libevmcore/Instruction.h>
+
+using namespace std;
+
+namespace dev
+{
+namespace solidity
+{
+
+void CompilerUtils::moveToStackVariable(VariableDeclaration const& _variable)
+{
+	unsigned const stackPosition = m_context.baseToCurrentStackOffset(m_context.getBaseStackOffsetOfVariable(_variable));
+	unsigned const size = _variable.getType()->getSizeOnStack();
+	for (unsigned i = 0; i < size; ++i)
+		m_context << eth::swapInstruction(stackPosition - size + 1) << eth::Instruction::POP;
+}
+
+void CompilerUtils::popStackElement(Type const& _type)
+{
+	unsigned const size = _type.getSizeOnStack();
+	for (unsigned i = 0; i < size; ++i)
+		m_context << eth::Instruction::POP;
+}
+
+}
+}

libsolidity/CompilerUtils.h

@@ -0,0 +1,47 @@
+/*
+	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/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2014
+ * Routines used by both the compiler and the expression compiler.
+ */
+
+#pragma once
+
+#include <libsolidity/CompilerContext.h>
+#include <libsolidity/ASTForward.h>
+
+namespace dev {
+namespace solidity {
+
+class Type; // forward
+
+class CompilerUtils
+{
+public:
+	CompilerUtils(CompilerContext& _context): m_context(_context) {}
+
+	/// Moves the value that is at the top of the stack to a stack variable.
+	void moveToStackVariable(VariableDeclaration const& _variable);
+	/// Removes the current value from the top of the stack.
+	void popStackElement(Type const& _type);
+private:
+	CompilerContext& m_context;
+};
+
+}
+}