From fd62adebf3e594298c171e43e78153dbefc42759 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Tue, 14 Feb 2017 18:14:40 +0100
Subject: Tests for labels with stack information.

---
 test/libsolidity/InlineAssembly.cpp       | 10 ++++++++++
 test/libsolidity/SolidityEndToEndTest.cpp | 27 +++++++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/test/libsolidity/InlineAssembly.cpp b/test/libsolidity/InlineAssembly.cpp
index 9035599b..824fce95 100644
--- a/test/libsolidity/InlineAssembly.cpp
+++ b/test/libsolidity/InlineAssembly.cpp
@@ -200,6 +200,11 @@ BOOST_AUTO_TEST_CASE(blocks)
 	BOOST_CHECK(successParse("{ let x := 7 { let y := 3 } { let z := 2 } }"));
 }
 
+BOOST_AUTO_TEST_CASE(labels_with_stack_info)
+{
+	BOOST_CHECK(successParse("{ x[-1]: y[a]: z[d, e]: h[100]: g[]: }"));
+}
+
 BOOST_AUTO_TEST_CASE(function_definitions)
 {
 	BOOST_CHECK(successParse("{ function f() { } function g(a) -> (x) { } }"));
@@ -244,6 +249,11 @@ BOOST_AUTO_TEST_CASE(print_label)
 	parsePrintCompare("{\n    loop:\n    jump(loop)\n}");
 }
 
+BOOST_AUTO_TEST_CASE(print_label_with_stack)
+{
+	parsePrintCompare("{\n    loop[x, y]:\n    other[-2]:\n    third[10]:\n}");
+}
+
 BOOST_AUTO_TEST_CASE(print_assignments)
 {
 	parsePrintCompare("{\n    let x := mul(2, 3)\n    7\n    =: x\n    x := add(1, 2)\n}");
diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp
index cb0cc168..d2028344 100644
--- a/test/libsolidity/SolidityEndToEndTest.cpp
+++ b/test/libsolidity/SolidityEndToEndTest.cpp
@@ -7418,6 +7418,33 @@ BOOST_AUTO_TEST_CASE(inline_assembly_function_access)
 	BOOST_CHECK(callContractFunction("x()") == encodeArgs(u256(10)));
 }
 
+BOOST_AUTO_TEST_CASE(inline_assembly_labels_with_stack_info)
+{
+	char const* sourceCode = R"(
+		contract C {
+			function f(uint y) {
+				assembly {
+					y 7
+					jump(fun)
+					exit[-1]:
+					y add
+					0 mstore
+					return(0, 0x20)
+					fun:
+					{
+						entry[a, b]:
+						a := div(a, b)
+						pop
+						jump(exit)
+					}
+				}
+			}
+		}
+	)";
+	compileAndRun(sourceCode, 0, "C");
+	BOOST_CHECK(callContractFunction("f(uint256)", u256(15)) == encodeArgs(15 / 7 + 15));
+}
+
 BOOST_AUTO_TEST_CASE(index_access_with_type_conversion)
 {
 	// Test for a bug where higher order bits cleanup was not done for array index access.
-- 
cgit 


From 98e343b3fc11f3e94297b016c3f625e3b319b09b Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Wed, 1 Feb 2017 21:40:50 +0100
Subject: Parsing of labels with stack info.

---
 libsolidity/inlineasm/AsmCodeGen.cpp |  1 +
 libsolidity/inlineasm/AsmData.h      |  4 ++--
 libsolidity/inlineasm/AsmParser.cpp  | 32 ++++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmPrinter.cpp |  6 +++++-
 4 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index faa7dabd..abc0ca01 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -91,6 +91,7 @@ public:
 	void operator()(T const& /*_item*/) { }
 	void operator()(Label const& _item)
 	{
+		solAssert(_item.stackInfo.empty(), "Labels with stack info not yet supported.");
 		if (m_state.labels.count(_item.name))
 			//@TODO secondary location
 			m_state.addError(
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index d61b5803..5969bf96 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -42,8 +42,8 @@ struct Literal { SourceLocation location; bool isNumber; std::string value; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
-/// Jump label ("name:")
-struct Label { SourceLocation location; std::string name; };
+/// Jump label ("name:" or "name [x, y, z]:" or "name [-3]:")
+struct Label { SourceLocation location; std::string name; std::vector<std::string> stackInfo; };
 /// Assignemnt (":= x", moves stack top into x, potentially multiple slots)
 struct Assignment { SourceLocation location; Identifier variableName; };
 struct FunctionalAssignment;
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 0fc0a34f..5d439b2f 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -121,6 +121,38 @@ assembly::Statement Parser::parseStatement()
 			return label;
 		}
 	}
+	case Token::LBrack:
+	{
+		if (statement.type() != typeid(assembly::Identifier))
+			fatalParserError("Label name must precede \"[\".");
+		assembly::Identifier const& identifier = boost::get<assembly::Identifier>(statement);
+		Label label = createWithLocation<Label>(identifier.location);
+		label.name = identifier.name;
+		m_scanner->next();
+		if (m_scanner->currentToken() == Token::Number)
+		{
+			label.stackInfo.push_back(m_scanner->currentLiteral());
+			m_scanner->next();
+		}
+		else if (m_scanner->currentToken() == Token::Sub)
+		{
+			m_scanner->next();
+			label.stackInfo.push_back("-" + m_scanner->currentLiteral());
+			expectToken(Token::Number);
+		}
+		else
+			while (true)
+			{
+				label.stackInfo.push_back(expectAsmIdentifier());
+				if (m_scanner->currentToken() == Token::RBrack)
+					break;
+				expectToken(Token::Comma);
+			}
+		expectToken(Token::RBrack);
+		label.location.end = endPosition();
+		expectToken(Token::Colon);
+		return label;
+	}
 	default:
 		break;
 	}
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index a70b0b78..5ec83281 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -94,7 +94,11 @@ string AsmPrinter::operator()(assembly::FunctionalInstruction const& _functional
 
 string AsmPrinter::operator()(assembly::Label const& _label)
 {
-	return _label.name + ":";
+	return _label.name + (
+		!_label.stackInfo.empty() ?
+		"[" +  boost::algorithm::join(_label.stackInfo, ", ") + "]" :
+		string()
+	) + ":";
 }
 
 string AsmPrinter::operator()(assembly::Assignment const& _assignment)
-- 
cgit 


From 7f2def89715a7ec663afa0e7342d6a4fa8d5b316 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Wed, 15 Feb 2017 14:52:53 +0100
Subject: Analysis refactoring.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 179 ++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmAnalysis.h   | 152 ++++++++++++++++++++++
 libsolidity/inlineasm/AsmCodeGen.cpp  | 231 +++++++++++++++++-----------------
 libsolidity/inlineasm/AsmParser.cpp   |   4 +
 libsolidity/inlineasm/AsmStack.cpp    |   5 +-
 libsolidity/interface/Exceptions.cpp  |   8 ++
 libsolidity/interface/Exceptions.h    |   2 +
 7 files changed, 466 insertions(+), 115 deletions(-)
 create mode 100644 libsolidity/inlineasm/AsmAnalysis.cpp
 create mode 100644 libsolidity/inlineasm/AsmAnalysis.h

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
new file mode 100644
index 00000000..ef620b84
--- /dev/null
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -0,0 +1,179 @@
+/*
+	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/>.
+*/
+/**
+ * Analyzer part of inline assembly.
+ */
+
+#include <libsolidity/inlineasm/AsmAnalysis.h>
+
+#include <libsolidity/inlineasm/AsmData.h>
+
+#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/Utils.h>
+
+#include <boost/range/adaptor/reversed.hpp>
+
+#include <memory>
+#include <functional>
+
+using namespace std;
+using namespace dev;
+using namespace dev::solidity;
+using namespace dev::solidity::assembly;
+
+
+bool Scope::registerLabel(const string& _name, size_t _id)
+{
+	if (lookup(_name))
+		return false;
+	identifiers[_name] = Scope::Label(_id);
+	return true;
+}
+
+
+bool Scope::registerVariable(const string& _name)
+{
+	if (lookup(_name))
+		return false;
+	identifiers[_name] = Variable();
+	return true;
+}
+
+Scope::Identifier* Scope::lookup(string const& _name)
+{
+	if (identifiers.count(_name))
+		return &identifiers[_name];
+	else if (superScope)
+		return superScope->lookup(_name);
+	else
+		return nullptr;
+}
+
+AsmAnalyzer::AsmAnalyzer(AsmAnalyzer::Scopes& _scopes, ErrorList& _errors):
+	m_scopes(_scopes), m_errors(_errors)
+{
+	// Make the Solidity ErrorTag available to inline assembly
+	m_scopes[nullptr] = make_shared<Scope>();
+	m_scopes[nullptr]->identifiers["invalidJumpLabel"] = Scope::Label(Scope::Label::errorLabelId);
+	m_currentScope = m_scopes[nullptr].get();
+}
+
+bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
+{
+	if (!_literal.isNumber && _literal.value.size() > 32)
+	{
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::TypeError,
+			"string literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)"
+		));
+		return false;
+	}
+	return true;
+}
+
+bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
+{
+	bool success = true;
+	for (auto const& arg: _instr.arguments | boost::adaptors::reversed)
+		if (!boost::apply_visitor(*this, arg))
+			success = false;
+	if (!(*this)(_instr.instruction))
+		success = false;
+	return success;
+}
+
+bool AsmAnalyzer::operator()(Label const& _item)
+{
+	if (!m_currentScope->registerLabel(_item.name, Scope::Label::unassignedLabelId))
+	{
+		//@TODO secondary location
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::DeclarationError,
+			"Label name " + _item.name + " already taken in this scope.",
+			_item.location
+		));
+		return false;
+	}
+	bool success = true;
+	if (!_item.stackInfo.empty())
+	{
+		Scope::Label& label = boost::get<Scope::Label>(m_currentScope->identifiers[_item.name]);
+		if (_item.stackInfo.size() == 1)
+			try
+			{
+				label.stackAdjustment = boost::lexical_cast<int>(_item.stackInfo[0]);
+				label.resetStackHeight = false;
+				return true;
+			}
+			catch (boost::bad_lexical_cast const&)
+			{
+				// Interpret as variable name
+			}
+		label.resetStackHeight = true;
+		for (auto const& stackItem: _item.stackInfo)
+		{
+			if (!m_currentScope->registerVariable(stackItem))
+			{
+				//@TODO secondary location
+				m_errors.push_back(make_shared<Error>(
+					Error::Type::DeclarationError,
+					"Variable name " + stackItem + " already taken in this scope.",
+					_item.location
+				));
+				success = false;
+			}
+		}
+	}
+	return success;
+}
+
+bool AsmAnalyzer::operator()(const FunctionalAssignment& _assignment)
+{
+	return boost::apply_visitor(*this, *_assignment.value);
+}
+
+bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
+{
+	bool success = boost::apply_visitor(*this, *_varDecl.value);
+	if (!m_currentScope->registerVariable(_varDecl.name))
+	{
+		//@TODO secondary location
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::DeclarationError,
+			"Variable name " + _varDecl.name + " already taken in this scope.",
+			_varDecl.location
+		));
+		success = false;
+	}
+	return success;
+}
+
+bool AsmAnalyzer::operator()(Block const& _block)
+{
+	bool success = true;
+	auto scope = make_shared<Scope>();
+	scope->superScope = m_currentScope;
+	m_scopes[&_block] = scope;
+	m_currentScope = scope.get();
+
+	for (auto const& s: _block.statements)
+		if (!boost::apply_visitor(*this, s))
+			success = false;
+
+	m_currentScope = m_currentScope->superScope;
+	return success;
+}
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
new file mode 100644
index 00000000..6b79ca67
--- /dev/null
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -0,0 +1,152 @@
+/*
+	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/>.
+*/
+/**
+ * Analysis part of inline assembly.
+ */
+
+#pragma once
+
+#include <libsolidity/interface/Exceptions.h>
+
+#include <boost/variant.hpp>
+
+#include <functional>
+#include <memory>
+
+namespace dev
+{
+namespace solidity
+{
+namespace assembly
+{
+
+struct Literal;
+struct Block;
+struct Label;
+struct FunctionalInstruction;
+struct FunctionalAssignment;
+struct VariableDeclaration;
+struct Instruction;
+struct Identifier;
+struct Assignment;
+
+struct Scope
+{
+	struct Variable
+	{
+		int stackHeight = 0;
+		bool active = false;
+	};
+
+	struct Label
+	{
+		Label(size_t _id): id(_id) {}
+		size_t id = 0;
+		int stackAdjustment = 0;
+		bool resetStackHeight = false;
+		static const size_t errorLabelId = -1;
+		static const size_t unassignedLabelId = 0;
+	};
+
+	using Identifier = boost::variant<Variable, Label>;
+
+	struct Visitor: public boost::static_visitor<>
+	{
+		Visitor(
+			std::function<void(Variable const&)> _varVisitor,
+			std::function<void(Label const&)> _labelVisitor
+		):
+			m_varVisitor(std::move(_varVisitor)),
+			m_labelVisitor(std::move(_labelVisitor))
+		{}
+
+		void operator()(Variable const& _var) const { m_varVisitor(_var); }
+		void operator()(Label const& _label) const { m_labelVisitor(_label); }
+
+		std::function<void(Variable const&)> m_varVisitor;
+		std::function<void(Label const&)> m_labelVisitor;
+	};
+	struct NonconstVisitor: public boost::static_visitor<>
+	{
+		NonconstVisitor(
+			std::function<void(Variable&)> _varVisitor,
+			std::function<void(Label&)> _labelVisitor
+		):
+			m_varVisitor(std::move(_varVisitor)),
+			m_labelVisitor(std::move(_labelVisitor))
+		{}
+
+		void operator()(Variable& _var) const { m_varVisitor(_var); }
+		void operator()(Label& _label) const { m_labelVisitor(_label); }
+
+		std::function<void(Variable&)> m_varVisitor;
+		std::function<void(Label&)> m_labelVisitor;
+	};
+
+	bool registerLabel(std::string const& _name, size_t _id);
+
+	bool registerVariable(std::string const& _name);
+
+	/// Looks up the identifier in this or super scopes and returns a valid pointer if
+	/// found or a nullptr if not found.
+	/// The pointer will be invalidated if the scope is modified.
+	Identifier* lookup(std::string const& _name);
+	/// Looks up the identifier in this and super scopes and calls the visitor, returns false if not found.
+	template <class V>
+	bool lookup(std::string const& _name, V const& _visitor)
+	{
+		if (Identifier* id = lookup(_name))
+		{
+			boost::apply_visitor(_visitor, *id);
+			return true;
+		}
+		else
+			return false;
+	}
+
+
+
+	Scope* superScope = nullptr;
+	std::map<std::string, Identifier> identifiers;
+};
+
+
+class AsmAnalyzer: public boost::static_visitor<bool>
+{
+public:
+	using Scopes = std::map<assembly::Block const*, std::shared_ptr<Scope>>;
+	AsmAnalyzer(Scopes& _scopes, ErrorList& _errors);
+
+	bool operator()(assembly::Instruction const&) { return true; }
+	bool operator()(assembly::Literal const& _literal);
+	bool operator()(assembly::Identifier const&) { return true; }
+	bool operator()(assembly::FunctionalInstruction const& _functionalInstruction);
+	bool operator()(assembly::Label const& _label);
+	bool operator()(assembly::Assignment const&) { return true; }
+	bool operator()(assembly::FunctionalAssignment const& _functionalAssignment);
+	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
+	bool operator()(assembly::Block const& _block);
+
+private:
+	Scope* m_currentScope = nullptr;
+	Scopes& m_scopes;
+	ErrorList& m_errors;
+};
+
+}
+}
+}
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index abc0ca01..0c802310 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -21,14 +21,21 @@
  */
 
 #include <libsolidity/inlineasm/AsmCodeGen.h>
-#include <memory>
-#include <functional>
-#include <libdevcore/CommonIO.h>
+
+#include <libsolidity/inlineasm/AsmParser.h>
+#include <libsolidity/inlineasm/AsmData.h>
+#include <libsolidity/inlineasm/AsmAnalysis.h>
+
 #include <libevmasm/Assembly.h>
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/Instruction.h>
-#include <libsolidity/inlineasm/AsmParser.h>
-#include <libsolidity/inlineasm/AsmData.h>
+
+#include <libdevcore/CommonIO.h>
+
+#include <boost/range/adaptor/reversed.hpp>
+
+#include <memory>
+#include <functional>
 
 using namespace std;
 using namespace dev;
@@ -42,74 +49,26 @@ struct GeneratorState
 
 	void addError(Error::Type _type, std::string const& _description, SourceLocation const& _location = SourceLocation())
 	{
-		auto err = make_shared<Error>(_type);
-		if (!_location.isEmpty())
-			*err << errinfo_sourceLocation(_location);
-		*err << errinfo_comment(_description);
-		errors.push_back(err);
+		errors.push_back(make_shared<Error>(_type, _description, _location));
 	}
 
-	int const* findVariable(string const& _variableName) const
+	size_t newLabelId()
 	{
-		auto localVariable = find_if(
-			variables.rbegin(),
-			variables.rend(),
-			[&](pair<string, int> const& _var) { return _var.first == _variableName; }
-		);
-		return localVariable != variables.rend() ? &localVariable->second : nullptr;
+		return assemblyTagToIdentifier(assembly.newTag());
 	}
-	eth::AssemblyItem const* findLabel(string const& _labelName) const
+
+	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
-		auto label = find_if(
-			labels.begin(),
-			labels.end(),
-			[&](pair<string, eth::AssemblyItem> const& _label) { return _label.first == _labelName; }
-		);
-		return label != labels.end() ? &label->second : nullptr;
+		u256 id = _tag.data();
+		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
+		return size_t(id);
 	}
 
-	map<string, eth::AssemblyItem> labels;
-	vector<pair<string, int>> variables; ///< name plus stack height
+	std::map<assembly::Block const*, shared_ptr<Scope>> scopes;
 	ErrorList& errors;
 	eth::Assembly& assembly;
 };
 
-/**
- * Scans the inline assembly data for labels, creates tags in the assembly and searches for
- * duplicate labels.
- */
-class LabelOrganizer: public boost::static_visitor<>
-{
-public:
-	LabelOrganizer(GeneratorState& _state): m_state(_state)
-	{
-		// Make the Solidity ErrorTag available to inline assembly
-		m_state.labels.insert(make_pair("invalidJumpLabel", m_state.assembly.errorTag()));
-	}
-
-	template <class T>
-	void operator()(T const& /*_item*/) { }
-	void operator()(Label const& _item)
-	{
-		solAssert(_item.stackInfo.empty(), "Labels with stack info not yet supported.");
-		if (m_state.labels.count(_item.name))
-			//@TODO secondary location
-			m_state.addError(
-				Error::Type::DeclarationError,
-				"Label " + _item.name + " declared twice.",
-				_item.location
-			);
-		m_state.labels.insert(make_pair(_item.name, m_state.assembly.newTag()));
-	}
-	void operator()(assembly::Block const& _block)
-	{
-		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
-	}
-
-private:
-	GeneratorState& m_state;
-};
-
 class CodeTransform: public boost::static_visitor<>
 {
 public:
@@ -126,6 +85,7 @@ public:
 			m_identifierAccess = _identifierAccess;
 		else
 			m_identifierAccess = [](assembly::Identifier const&, eth::Assembly&, CodeGenerator::IdentifierContext) { return false; };
+		m_currentScope = m_state.scopes[nullptr].get();
 	}
 
 	void operator()(assembly::Instruction const& _instruction)
@@ -138,40 +98,49 @@ public:
 		m_state.assembly.setSourceLocation(_literal.location);
 		if (_literal.isNumber)
 			m_state.assembly.append(u256(_literal.value));
-		else if (_literal.value.size() > 32)
-		{
-			m_state.addError(
-				Error::Type::TypeError,
-				"String literal too long (" + boost::lexical_cast<string>(_literal.value.size()) + " > 32)"
-			);
-			m_state.assembly.append(u256(0));
-		}
 		else
+		{
+			solAssert(_literal.value.size() <= 32, "");
 			m_state.assembly.append(_literal.value);
+		}
 	}
 	void operator()(assembly::Identifier const& _identifier)
 	{
 		m_state.assembly.setSourceLocation(_identifier.location);
-		// First search local variables, then labels, then externals.
-		if (int const* stackHeight = m_state.findVariable(_identifier.name))
-		{
-			int heightDiff = m_state.assembly.deposit() - *stackHeight;
-			if (heightDiff <= 0 || heightDiff > 16)
+		// First search internals, then externals.
+		if (!m_currentScope->lookup(_identifier.name, Scope::NonconstVisitor(
+			[=](Scope::Variable& _var)
 			{
-				m_state.addError(
-					Error::Type::TypeError,
-					"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
-					_identifier.location
-				);
-				m_state.assembly.append(u256(0));
+				if (!_var.active)
+				{
+					m_state.addError(
+						Error::Type::TypeError,
+						"Variable used before it was declared",
+						_identifier.location
+					);
+					m_state.assembly.append(u256(0));
+					return;
+				}
+				int heightDiff = m_state.assembly.deposit() - _var.stackHeight;
+				if (heightDiff <= 0 || heightDiff > 16)
+				{
+					m_state.addError(
+						Error::Type::TypeError,
+						"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
+						_identifier.location
+					);
+					m_state.assembly.append(u256(0));
+				}
+				else
+					m_state.assembly.append(solidity::dupInstruction(heightDiff));
+			},
+			[=](Scope::Label& _label)
+			{
+				if (_label.id == Scope::Label::unassignedLabelId)
+					_label.id = m_state.newLabelId();
+				m_state.assembly.append(eth::AssemblyItem(eth::PushTag, _label.id));
 			}
-			else
-				m_state.assembly.append(solidity::dupInstruction(heightDiff));
-			return;
-		}
-		else if (eth::AssemblyItem const* label = m_state.findLabel(_identifier.name))
-			m_state.assembly.append(label->pushTag());
-		else if (!m_identifierAccess(_identifier, m_state.assembly, CodeGenerator::IdentifierContext::RValue))
+		)))
 		{
 			m_state.addError(
 				Error::Type::DeclarationError,
@@ -197,8 +166,13 @@ public:
 	}
 	void operator()(Label const& _label)
 	{
+		solAssert(_label.stackInfo.empty(), "Labels with stack info not yet supported.");
 		m_state.assembly.setSourceLocation(_label.location);
-		m_state.assembly.append(m_state.labels.at(_label.name));
+		solAssert(m_currentScope->identifiers.count(_label.name), "");
+		Scope::Label& label = boost::get<Scope::Label>(m_currentScope->identifiers[_label.name]);
+		if (label.id == Scope::Label::unassignedLabelId)
+			label.id = m_state.newLabelId();
+		m_state.assembly.append(eth::AssemblyItem(eth::PushTag, label.id));
 	}
 	void operator()(assembly::Assignment const& _assignment)
 	{
@@ -218,23 +192,25 @@ public:
 		int height = m_state.assembly.deposit();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height, locationOf(*_varDecl.value));
-		m_state.variables.push_back(make_pair(_varDecl.name, height));
+		solAssert(m_currentScope && m_currentScope->identifiers.count(_varDecl.name), "");
+		auto& var = boost::get<Scope::Variable>(m_currentScope->identifiers[_varDecl.name]);
+		var.stackHeight = height;
+		var.active = true;
 	}
 	void operator()(assembly::Block const& _block)
 	{
-		size_t numVariables = m_state.variables.size();
+		solAssert(m_state.scopes.count(&_block), "Scope for block not defined.");
+		m_currentScope = m_state.scopes[&_block].get();
 		int deposit = m_state.assembly.deposit();
 		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
 
-		// pop variables
-		while (m_state.variables.size() > numVariables)
-		{
-			m_state.assembly.append(solidity::Instruction::POP);
-			m_state.variables.pop_back();
-		}
-
 		m_state.assembly.setSourceLocation(_block.location);
 
+		// pop variables
+		for (auto const& identifier: m_currentScope->identifiers)
+			if (identifier.second.type() == typeid(Scope::Variable))
+				m_state.assembly.append(solidity::Instruction::POP);
+
 		deposit = m_state.assembly.deposit() - deposit;
 
 		// issue warnings for stack height discrepancies
@@ -254,6 +230,8 @@ public:
 				_block.location
 			);
 		}
+
+		m_currentScope = m_currentScope->superScope;
 	}
 	void operator()(assembly::FunctionDefinition const&)
 	{
@@ -263,21 +241,38 @@ public:
 private:
 	void generateAssignment(assembly::Identifier const& _variableName, SourceLocation const& _location)
 	{
-		if (int const* stackHeight = m_state.findVariable(_variableName.name))
-		{
-			int heightDiff = m_state.assembly.deposit() - *stackHeight - 1;
-			if (heightDiff <= 0 || heightDiff > 16)
+		if (!m_currentScope->lookup(_variableName.name, Scope::Visitor(
+			[=](Scope::Variable const& _var)
+			{
+				if (!_var.active)
+				{
+					m_state.addError(
+						Error::Type::TypeError,
+						"Variable used before it was declared",
+						_location
+					);
+					m_state.assembly.append(u256(0));
+					return;
+				}
+				int heightDiff = m_state.assembly.deposit() - _var.stackHeight - 1;
+				if (heightDiff <= 0 || heightDiff > 16)
+					m_state.addError(
+						Error::Type::TypeError,
+						"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
+						_location
+					);
+				else
+					m_state.assembly.append(solidity::swapInstruction(heightDiff));
+				m_state.assembly.append(solidity::Instruction::POP);
+			},
+			[=](Scope::Label const&)
+			{
 				m_state.addError(
-					Error::Type::TypeError,
-					"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
-					_location
+					Error::Type::DeclarationError,
+					"Label \"" + string(_variableName.name) + "\" used as variable."
 				);
-			else
-				m_state.assembly.append(solidity::swapInstruction(heightDiff));
-			m_state.assembly.append(solidity::Instruction::POP);
-			return;
-		}
-		else if (!m_identifierAccess(_variableName, m_state.assembly, CodeGenerator::IdentifierContext::LValue))
+			}
+		)) && !m_identifierAccess(_variableName, m_state.assembly, CodeGenerator::IdentifierContext::LValue))
 			m_state.addError(
 				Error::Type::DeclarationError,
 				"Identifier \"" + string(_variableName.name) + "\" not found, not unique or not lvalue."
@@ -298,6 +293,7 @@ private:
 	}
 
 	GeneratorState& m_state;
+	Scope* m_currentScope;
 	assembly::CodeGenerator::IdentifierAccess m_identifierAccess;
 };
 
@@ -306,24 +302,31 @@ bool assembly::CodeGenerator::typeCheck(assembly::CodeGenerator::IdentifierAcces
 	size_t initialErrorLen = m_errors.size();
 	eth::Assembly assembly;
 	GeneratorState state(m_errors, assembly);
-	(LabelOrganizer(state))(m_parsedData);
+	if (!(AsmAnalyzer(state.scopes, m_errors))(m_parsedData))
+		return false;
 	(CodeTransform(state, _identifierAccess))(m_parsedData);
 	return m_errors.size() == initialErrorLen;
 }
 
 eth::Assembly assembly::CodeGenerator::assemble(assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
 {
+	size_t initialErrorLen = m_errors.size();
 	eth::Assembly assembly;
 	GeneratorState state(m_errors, assembly);
-	(LabelOrganizer(state))(m_parsedData);
+	if (!(AsmAnalyzer(state.scopes, m_errors))(m_parsedData))
+		solAssert(false, "Assembly error");
 	(CodeTransform(state, _identifierAccess))(m_parsedData);
+	solAssert(m_errors.size() == initialErrorLen, "Assembly error");
 	return assembly;
 }
 
 void assembly::CodeGenerator::assemble(eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
 {
+	size_t initialErrorLen = m_errors.size();
 	GeneratorState state(m_errors, _assembly);
-	(LabelOrganizer(state))(m_parsedData);
+	if (!(AsmAnalyzer(state.scopes, m_errors))(m_parsedData))
+		solAssert(false, "Assembly error");
 	(CodeTransform(state, _identifierAccess))(m_parsedData);
+	solAssert(m_errors.size() == initialErrorLen, "Assembly error");
 }
 
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 5d439b2f..779646b8 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -148,6 +148,10 @@ assembly::Statement Parser::parseStatement()
 					break;
 				expectToken(Token::Comma);
 			}
+		// Push an empty string to signify that there were brackets, like in
+		// "name[]:", which just resets the stack height to the height of the local variables.
+		if (label.stackInfo.empty())
+			label.stackInfo.push_back("");
 		expectToken(Token::RBrack);
 		label.location.end = endPosition();
 		expectToken(Token::Colon);
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index 38d688c1..266136a1 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -25,6 +25,7 @@
 #include <libsolidity/inlineasm/AsmParser.h>
 #include <libsolidity/inlineasm/AsmCodeGen.h>
 #include <libsolidity/inlineasm/AsmPrinter.h>
+#include <libsolidity/inlineasm/AsmAnalysis.h>
 
 #include <libsolidity/parsing/Scanner.h>
 
@@ -45,8 +46,10 @@ bool InlineAssemblyStack::parse(shared_ptr<Scanner> const& _scanner)
 	auto result = parser.parse(_scanner);
 	if (!result)
 		return false;
+
 	*m_parserResult = std::move(*result);
-	return true;
+	AsmAnalyzer::Scopes scopes;
+	return (AsmAnalyzer(scopes, m_errors))(*m_parserResult);
 }
 
 string InlineAssemblyStack::toString()
diff --git a/libsolidity/interface/Exceptions.cpp b/libsolidity/interface/Exceptions.cpp
index 41890b91..20f9dd75 100644
--- a/libsolidity/interface/Exceptions.cpp
+++ b/libsolidity/interface/Exceptions.cpp
@@ -58,6 +58,14 @@ Error::Error(Type _type): m_type(_type)
 	}
 }
 
+Error::Error(Error::Type _type, const std::string& _description, const SourceLocation& _location):
+	Error(_type)
+{
+	if (!_location.isEmpty())
+		*this << errinfo_sourceLocation(_location);
+	*this << errinfo_comment(_description);
+}
+
 string Exception::lineInfo() const
 {
 	char const* const* file = boost::get_error_info<boost::throw_file>(*this);
diff --git a/libsolidity/interface/Exceptions.h b/libsolidity/interface/Exceptions.h
index 81716c41..71699da8 100644
--- a/libsolidity/interface/Exceptions.h
+++ b/libsolidity/interface/Exceptions.h
@@ -55,6 +55,8 @@ public:
 
 	explicit Error(Type _type);
 
+	Error(Type _type, std::string const& _description, SourceLocation const& _location = SourceLocation());
+
 	Type type() const { return m_type; }
 	std::string const& typeName() const { return m_typeName; }
 
-- 
cgit 


From 25dcfa3480b2265d6dbb798849bfaadebc9a405c Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Wed, 15 Feb 2017 16:47:54 +0100
Subject: Refactor CodeGen to recurse on blocks.

---
 libsolidity/analysis/TypeChecker.cpp  |   7 +-
 libsolidity/inlineasm/AsmAnalysis.cpp |  29 ++++----
 libsolidity/inlineasm/AsmCodeGen.cpp  | 134 ++++++++++++++++++++--------------
 libsolidity/inlineasm/AsmParser.cpp   |   2 +-
 4 files changed, 97 insertions(+), 75 deletions(-)

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index ff55ef1f..66f5de6a 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -593,7 +593,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 	// code-generator and see whether it produces any errors.
 	// External references have already been resolved in a prior stage and stored in the annotation.
 	assembly::CodeGenerator codeGen(_inlineAssembly.operations(), m_errors);
-	codeGen.typeCheck([&](assembly::Identifier const& _identifier, eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierContext _context) {
+	if (!codeGen.typeCheck([&](assembly::Identifier const& _identifier, eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierContext _context) {
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
 		if (ref == _inlineAssembly.annotation().externalReferences.end())
 			return false;
@@ -641,8 +641,9 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 				return false;
 		}
 		return true;
-	});
-	return false;
+	}))
+		return false;
+	return true;
 }
 
 bool TypeChecker::visit(IfStatement const& _ifStatement)
diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ef620b84..133869ca 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -36,7 +36,7 @@ using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
 
-bool Scope::registerLabel(const string& _name, size_t _id)
+bool Scope::registerLabel(string const& _name, size_t _id)
 {
 	if (lookup(_name))
 		return false;
@@ -45,7 +45,7 @@ bool Scope::registerLabel(const string& _name, size_t _id)
 }
 
 
-bool Scope::registerVariable(const string& _name)
+bool Scope::registerVariable(string const& _name)
 {
 	if (lookup(_name))
 		return false;
@@ -125,23 +125,22 @@ bool AsmAnalyzer::operator()(Label const& _item)
 			}
 		label.resetStackHeight = true;
 		for (auto const& stackItem: _item.stackInfo)
-		{
-			if (!m_currentScope->registerVariable(stackItem))
-			{
-				//@TODO secondary location
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Variable name " + stackItem + " already taken in this scope.",
-					_item.location
-				));
-				success = false;
-			}
-		}
+			if (!stackItem.empty())
+				if (!m_currentScope->registerVariable(stackItem))
+				{
+					//@TODO secondary location
+					m_errors.push_back(make_shared<Error>(
+						Error::Type::DeclarationError,
+						"Variable name " + stackItem + " already taken in this scope.",
+						_item.location
+					));
+					success = false;
+				}
 	}
 	return success;
 }
 
-bool AsmAnalyzer::operator()(const FunctionalAssignment& _assignment)
+bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
 {
 	return boost::apply_visitor(*this, *_assignment.value);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 0c802310..c6142011 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -33,6 +33,8 @@
 #include <libdevcore/CommonIO.h>
 
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/adaptor/map.hpp>
+#include <boost/range/algorithm/count_if.hpp>
 
 #include <memory>
 #include <functional>
@@ -77,15 +79,42 @@ public:
 	/// @param _identifierAccess used to resolve identifiers external to the inline assembly
 	explicit CodeTransform(
 		GeneratorState& _state,
+		assembly::Block const& _block,
 		assembly::CodeGenerator::IdentifierAccess const& _identifierAccess = assembly::CodeGenerator::IdentifierAccess()
 	):
-		m_state(_state)
+		m_state(_state),
+		m_scope(*m_state.scopes.at(&_block)),
+		m_initialDeposit(m_state.assembly.deposit()),
+		m_identifierAccess(_identifierAccess)
 	{
-		if (_identifierAccess)
-			m_identifierAccess = _identifierAccess;
-		else
-			m_identifierAccess = [](assembly::Identifier const&, eth::Assembly&, CodeGenerator::IdentifierContext) { return false; };
-		m_currentScope = m_state.scopes[nullptr].get();
+		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
+
+		m_state.assembly.setSourceLocation(_block.location);
+
+		// pop variables
+		for (auto const& identifier: m_scope.identifiers)
+			if (identifier.second.type() == typeid(Scope::Variable))
+				m_state.assembly.append(solidity::Instruction::POP);
+
+		int deposit = m_state.assembly.deposit() - m_initialDeposit;
+
+		// issue warnings for stack height discrepancies
+		if (deposit < 0)
+		{
+			m_state.addError(
+				Error::Type::Warning,
+				"Inline assembly block is not balanced. It takes " + toString(-deposit) + " item(s) from the stack.",
+				_block.location
+			);
+		}
+		else if (deposit > 0)
+		{
+			m_state.addError(
+				Error::Type::Warning,
+				"Inline assembly block is not balanced. It leaves " + toString(deposit) + " item(s) on the stack.",
+				_block.location
+			);
+		}
 	}
 
 	void operator()(assembly::Instruction const& _instruction)
@@ -108,7 +137,7 @@ public:
 	{
 		m_state.assembly.setSourceLocation(_identifier.location);
 		// First search internals, then externals.
-		if (!m_currentScope->lookup(_identifier.name, Scope::NonconstVisitor(
+		if (m_scope.lookup(_identifier.name, Scope::NonconstVisitor(
 			[=](Scope::Variable& _var)
 			{
 				if (!_var.active)
@@ -138,9 +167,14 @@ public:
 			{
 				if (_label.id == Scope::Label::unassignedLabelId)
 					_label.id = m_state.newLabelId();
+				else if (_label.id == Scope::Label::errorLabelId)
+					_label.id = size_t(m_state.assembly.errorTag().data());
 				m_state.assembly.append(eth::AssemblyItem(eth::PushTag, _label.id));
 			}
 		)))
+		{
+		}
+		else if (!m_identifierAccess || !m_identifierAccess(_identifier, m_state.assembly, CodeGenerator::IdentifierContext::RValue))
 		{
 			m_state.addError(
 				Error::Type::DeclarationError,
@@ -166,13 +200,33 @@ public:
 	}
 	void operator()(Label const& _label)
 	{
-		solAssert(_label.stackInfo.empty(), "Labels with stack info not yet supported.");
 		m_state.assembly.setSourceLocation(_label.location);
-		solAssert(m_currentScope->identifiers.count(_label.name), "");
-		Scope::Label& label = boost::get<Scope::Label>(m_currentScope->identifiers[_label.name]);
+		solAssert(m_scope.identifiers.count(_label.name), "");
+		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers[_label.name]);
 		if (label.id == Scope::Label::unassignedLabelId)
 			label.id = m_state.newLabelId();
-		m_state.assembly.append(eth::AssemblyItem(eth::PushTag, label.id));
+		else if (label.id == Scope::Label::errorLabelId)
+			label.id = size_t(m_state.assembly.errorTag().data());
+		if (label.resetStackHeight)
+		{
+			size_t numVariables = boost::range::count_if(
+				 m_scope.identifiers | boost::adaptors::map_values,
+				[](Scope::Identifier const& var) { return var.type() == typeid(Scope::Variable) && boost::get<Scope::Variable>(var).active; }
+			);
+			for (auto const& identifier: _label.stackInfo)
+				if (!identifier.empty())
+				{
+					solAssert(m_scope.identifiers.count(identifier), "");
+					Scope::Variable& var = boost::get<Scope::Variable>(m_scope.identifiers[identifier]);
+					var.active = true;
+					var.stackHeight = m_initialDeposit + numVariables;
+					numVariables++;
+				}
+			m_state.assembly.setDeposit(m_initialDeposit + numVariables);
+		}
+		else if (label.stackAdjustment != 0)
+			m_state.assembly.adjustDeposit(label.stackAdjustment);
+		m_state.assembly.append(eth::AssemblyItem(eth::Tag, label.id));
 	}
 	void operator()(assembly::Assignment const& _assignment)
 	{
@@ -192,46 +246,14 @@ public:
 		int height = m_state.assembly.deposit();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height, locationOf(*_varDecl.value));
-		solAssert(m_currentScope && m_currentScope->identifiers.count(_varDecl.name), "");
-		auto& var = boost::get<Scope::Variable>(m_currentScope->identifiers[_varDecl.name]);
+		solAssert(m_scope.identifiers.count(_varDecl.name), "");
+		auto& var = boost::get<Scope::Variable>(m_scope.identifiers[_varDecl.name]);
 		var.stackHeight = height;
 		var.active = true;
 	}
 	void operator()(assembly::Block const& _block)
 	{
-		solAssert(m_state.scopes.count(&_block), "Scope for block not defined.");
-		m_currentScope = m_state.scopes[&_block].get();
-		int deposit = m_state.assembly.deposit();
-		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
-
-		m_state.assembly.setSourceLocation(_block.location);
-
-		// pop variables
-		for (auto const& identifier: m_currentScope->identifiers)
-			if (identifier.second.type() == typeid(Scope::Variable))
-				m_state.assembly.append(solidity::Instruction::POP);
-
-		deposit = m_state.assembly.deposit() - deposit;
-
-		// issue warnings for stack height discrepancies
-		if (deposit < 0)
-		{
-			m_state.addError(
-				Error::Type::Warning,
-				"Inline assembly block is not balanced. It takes " + toString(-deposit) + " item(s) from the stack.",
-				_block.location
-			);
-		}
-		else if (deposit > 0)
-		{
-			m_state.addError(
-				Error::Type::Warning,
-				"Inline assembly block is not balanced. It leaves " + toString(deposit) + " item(s) on the stack.",
-				_block.location
-			);
-		}
-
-		m_currentScope = m_currentScope->superScope;
+		CodeTransform(m_state, _block, m_identifierAccess);
 	}
 	void operator()(assembly::FunctionDefinition const&)
 	{
@@ -241,7 +263,7 @@ public:
 private:
 	void generateAssignment(assembly::Identifier const& _variableName, SourceLocation const& _location)
 	{
-		if (!m_currentScope->lookup(_variableName.name, Scope::Visitor(
+		if (m_scope.lookup(_variableName.name, Scope::Visitor(
 			[=](Scope::Variable const& _var)
 			{
 				if (!_var.active)
@@ -272,7 +294,10 @@ private:
 					"Label \"" + string(_variableName.name) + "\" used as variable."
 				);
 			}
-		)) && !m_identifierAccess(_variableName, m_state.assembly, CodeGenerator::IdentifierContext::LValue))
+		)))
+		{
+		}
+		else if (!m_identifierAccess || !m_identifierAccess(_variableName, m_state.assembly, CodeGenerator::IdentifierContext::LValue))
 			m_state.addError(
 				Error::Type::DeclarationError,
 				"Identifier \"" + string(_variableName.name) + "\" not found, not unique or not lvalue."
@@ -293,7 +318,8 @@ private:
 	}
 
 	GeneratorState& m_state;
-	Scope* m_currentScope;
+	Scope& m_scope;
+	int const m_initialDeposit;
 	assembly::CodeGenerator::IdentifierAccess m_identifierAccess;
 };
 
@@ -304,29 +330,25 @@ bool assembly::CodeGenerator::typeCheck(assembly::CodeGenerator::IdentifierAcces
 	GeneratorState state(m_errors, assembly);
 	if (!(AsmAnalyzer(state.scopes, m_errors))(m_parsedData))
 		return false;
-	(CodeTransform(state, _identifierAccess))(m_parsedData);
+	CodeTransform(state, m_parsedData, _identifierAccess);
 	return m_errors.size() == initialErrorLen;
 }
 
 eth::Assembly assembly::CodeGenerator::assemble(assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
 {
-	size_t initialErrorLen = m_errors.size();
 	eth::Assembly assembly;
 	GeneratorState state(m_errors, assembly);
 	if (!(AsmAnalyzer(state.scopes, m_errors))(m_parsedData))
 		solAssert(false, "Assembly error");
-	(CodeTransform(state, _identifierAccess))(m_parsedData);
-	solAssert(m_errors.size() == initialErrorLen, "Assembly error");
+	CodeTransform(state, m_parsedData, _identifierAccess);
 	return assembly;
 }
 
 void assembly::CodeGenerator::assemble(eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
 {
-	size_t initialErrorLen = m_errors.size();
 	GeneratorState state(m_errors, _assembly);
 	if (!(AsmAnalyzer(state.scopes, m_errors))(m_parsedData))
 		solAssert(false, "Assembly error");
-	(CodeTransform(state, _identifierAccess))(m_parsedData);
-	solAssert(m_errors.size() == initialErrorLen, "Assembly error");
+	CodeTransform(state, m_parsedData, _identifierAccess);
 }
 
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 779646b8..9f24d9fb 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -140,7 +140,7 @@ assembly::Statement Parser::parseStatement()
 			label.stackInfo.push_back("-" + m_scanner->currentLiteral());
 			expectToken(Token::Number);
 		}
-		else
+		else if (m_scanner->currentToken() != Token::RBrack)
 			while (true)
 			{
 				label.stackInfo.push_back(expectAsmIdentifier());
-- 
cgit 


From f4f82615b129974c811288a5af8e40c95548f11b Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Thu, 16 Feb 2017 09:44:05 +0100
Subject: Updated documentation.

---
 docs/assembly.rst | 58 ++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 47 insertions(+), 11 deletions(-)

diff --git a/docs/assembly.rst b/docs/assembly.rst
index 23ccfcbe..b28216f1 100644
--- a/docs/assembly.rst
+++ b/docs/assembly.rst
@@ -361,7 +361,9 @@ Labels
 
 Another problem in EVM assembly is that ``jump`` and ``jumpi`` use absolute addresses
 which can change easily. Solidity inline assembly provides labels to make the use of
-jumps easier. The following code computes an element in the Fibonacci series.
+jumps easier. Note that labels are a low-level feature and it is possible to write
+efficient assembly without labels, just using assembly functions, loops and switch instructions
+(see below). The following code computes an element in the Fibonacci series.
 
 .. code::
 
@@ -391,12 +393,35 @@ will have a wrong impression about the stack height at label ``two``:
 .. code::
 
     {
+        let x := 8
         jump(two)
         one:
-            // Here the stack height is 1 (because we pushed 7),
-            // but the assembler thinks it is 0 because it reads
+            // Here the stack height is 2 (because we pushed x and 7),
+            // but the assembler thinks it is 1 because it reads
             // from top to bottom.
-            // Accessing stack variables here will lead to errors.
+            // Accessing the stack variable x here will lead to errors.
+            x := 9
+            jump(three)
+        two:
+            7 // push something onto the stack
+            jump(one)
+        three:
+    }
+
+This problem can be fixed by manually adjusting the stack height for the
+assembler - you can provide a stack height delta that is added
+to the stack height just prior to the label.
+Note that you will not have to care about these things if you just use
+loops and assembly-level functions.
+
+.. code::
+
+    {
+        let x := 8
+        jump(two)
+        one[1]:
+            // Now the stack height is correctly adjusted.
+            x := 9
             jump(three)
         two:
             7 // push something onto the stack
@@ -464,6 +489,9 @@ is performed by replacing the variable's value on the stack by the new value.
 Switch
 ------
 
+.. note::
+    Switch is not yet implemented.
+
 You can use a switch statement as a very basic version of "if/else".
 It takes the value of an expression and compares it to several constants.
 The branch corresponding to the matching constant is taken. Contrary to the
@@ -491,6 +519,9 @@ case does require them.
 Loops
 -----
 
+.. note::
+    Loops are not yet implemented.
+
 Assembly supports a simple for-style loop. For-style loops have
 a header containing an initializing part, a condition and a post-iteration
 part. The condition has to be a functional-style expression, while
@@ -512,6 +543,9 @@ The following example computes the sum of an area in memory.
 Functions
 ---------
 
+.. note::
+    Functions are not yet implemented.
+
 Assembly allows the definition of low-level functions. These take their
 arguments (and a return PC) from the stack and also put the results onto the
 stack. Calling a function looks the same way as executing a functional-style
@@ -610,8 +644,7 @@ which follow very simple and regular scoping rules and cleanup of local variable
 Scoping: An identifier that is declared (label, variable, function, assembly)
 is only visible in the block where it was declared (including nested blocks
 inside the current block). It is not legal to access local variables across
-function borders, even if they would be in scope. Shadowing is allowed, but
-two identifiers with the same name cannot be declared in the same block.
+function borders, even if they would be in scope. Shadowing is not allowed.
 Local variables cannot be accessed before they were declared, but labels,
 functions and assemblies can. Assemblies are special blocks that are used
 for e.g. returning runtime code or creating contracts. No identifier from an
@@ -624,7 +657,7 @@ flow path. Whenever a local variable is referenced, the code generator needs
 to know its current relative position in the stack and thus it needs to
 keep track of the current so-called stack height.
 At the end of a block, this implicit stack height is always reduced by the number
-of local variables whether ther is a continuing control flow or not.
+of local variables whether there is a continuing control flow or not.
 
 This means that the stack height before and after the block should be the same.
 If this is not the case, a warning is issued,
@@ -805,7 +838,7 @@ Grammar::
     IdentifierOrList = Identifier | '(' IdentifierList ')'
     IdentifierList = Identifier ( ',' Identifier)*
     AssemblyAssignment = '=:' Identifier
-    LabelDefinition = Identifier ( '[' ( IdentifierList | NumberLiteral ) ']' )? ':'
+    LabelDefinition = Identifier ( '[' ( IdentifierList? | NumberLiteral ) ']' )? ':'
     AssemblySwitch = 'switch' FunctionalAssemblyExpression AssemblyCase*
         ( 'default' ':' AssemblyBlock )?
     AssemblyCase = 'case' FunctionalAssemblyExpression ':' AssemblyBlock
@@ -947,11 +980,14 @@ Pseudocode::
       POP
     LabelDefinition(name [id1, ..., idn] :) ->
       JUMPDEST
-      // register new variables id1, ..., idn and set the stack height to
-      // stack_height_at_block_start + number_of_local_variables
+      // register new variables id1, ..., idn and adjust the assumed stack
+      // height such that it matches the stack height at the beginning of
+      // the block plus all local variables including the just registered
+      // ones where idn is at the stack top. If n is zero, resets the stack
+      // height to just the local variables.
     LabelDefinition(name [number] :) ->
       JUMPDEST
-      // adjust stack height by +number (can be negative)
+      // adjust stack height by the relative amount "number" (can be negative)
     NumberLiteral(num) ->
       PUSH<num interpreted as decimal and right-aligned>
     HexLiteral(lit) ->
-- 
cgit 


From caa3761dc9be5963d2a5f6448db117fb6272b911 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Thu, 16 Feb 2017 10:12:54 +0100
Subject: Refactor variable access.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 70 ++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 40 deletions(-)

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index c6142011..c1efc72c 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -140,28 +140,11 @@ public:
 		if (m_scope.lookup(_identifier.name, Scope::NonconstVisitor(
 			[=](Scope::Variable& _var)
 			{
-				if (!_var.active)
-				{
-					m_state.addError(
-						Error::Type::TypeError,
-						"Variable used before it was declared",
-						_identifier.location
-					);
-					m_state.assembly.append(u256(0));
-					return;
-				}
-				int heightDiff = m_state.assembly.deposit() - _var.stackHeight;
-				if (heightDiff <= 0 || heightDiff > 16)
-				{
-					m_state.addError(
-						Error::Type::TypeError,
-						"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
-						_identifier.location
-					);
-					m_state.assembly.append(u256(0));
-				}
-				else
+				if (int heightDiff = variableHeightDiff(_var, _identifier.location, false))
 					m_state.assembly.append(solidity::dupInstruction(heightDiff));
+				else
+					// Store something to balance the stack
+					m_state.assembly.append(u256(0));
 			},
 			[=](Scope::Label& _label)
 			{
@@ -266,25 +249,8 @@ private:
 		if (m_scope.lookup(_variableName.name, Scope::Visitor(
 			[=](Scope::Variable const& _var)
 			{
-				if (!_var.active)
-				{
-					m_state.addError(
-						Error::Type::TypeError,
-						"Variable used before it was declared",
-						_location
-					);
-					m_state.assembly.append(u256(0));
-					return;
-				}
-				int heightDiff = m_state.assembly.deposit() - _var.stackHeight - 1;
-				if (heightDiff <= 0 || heightDiff > 16)
-					m_state.addError(
-						Error::Type::TypeError,
-						"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
-						_location
-					);
-				else
-					m_state.assembly.append(solidity::swapInstruction(heightDiff));
+				if (int heightDiff = variableHeightDiff(_var, _location, true))
+					m_state.assembly.append(solidity::swapInstruction(heightDiff - 1));
 				m_state.assembly.append(solidity::Instruction::POP);
 			},
 			[=](Scope::Label const&)
@@ -304,6 +270,30 @@ private:
 			);
 	}
 
+	/// Determines the stack height difference to the given variables. Automatically generates
+	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
+	/// errors and the (positive) stack height difference otherwise.
+	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
+	{
+		if (!_var.active)
+		{
+			m_state.addError( Error::Type::TypeError, "Variable used before it was declared", _location);
+			return 0;
+		}
+		int heightDiff = m_state.assembly.deposit() - _var.stackHeight;
+		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
+		{
+			m_state.addError(
+				Error::Type::TypeError,
+				"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
+				_location
+			);
+			return 0;
+		}
+		else
+			return heightDiff;
+	}
+
 	void expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location)
 	{
 		if (m_state.assembly.deposit() != _oldHeight + 1)
-- 
cgit 


From 647473cf013f901bfa11f7327e9efce99abd3f22 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Thu, 16 Feb 2017 23:55:13 +0100
Subject: Generic visitor.

---
 libsolidity/inlineasm/AsmAnalysis.h | 65 ++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 37 deletions(-)

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 6b79ca67..f00ad3d8 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -44,6 +44,31 @@ struct Instruction;
 struct Identifier;
 struct Assignment;
 
+template <class...>
+struct GenericVisitor{};
+
+template <class Visitable, class... Others>
+struct GenericVisitor<Visitable, Others...>: public GenericVisitor<Others...>
+{
+	using GenericVisitor<Others...>::operator ();
+	explicit GenericVisitor(
+		std::function<void(Visitable&)> _visitor,
+		std::function<void(Others&)>... _otherVisitors
+	):
+		GenericVisitor<Others...>(_otherVisitors...),
+		m_visitor(_visitor)
+	{}
+
+	void operator()(Visitable& _v) const { m_visitor(_v); }
+
+	std::function<void(Visitable&)> m_visitor;
+};
+template <>
+struct GenericVisitor<>: public boost::static_visitor<> {
+	void operator()() const {}
+};
+
+
 struct Scope
 {
 	struct Variable
@@ -63,43 +88,11 @@ struct Scope
 	};
 
 	using Identifier = boost::variant<Variable, Label>;
-
-	struct Visitor: public boost::static_visitor<>
-	{
-		Visitor(
-			std::function<void(Variable const&)> _varVisitor,
-			std::function<void(Label const&)> _labelVisitor
-		):
-			m_varVisitor(std::move(_varVisitor)),
-			m_labelVisitor(std::move(_labelVisitor))
-		{}
-
-		void operator()(Variable const& _var) const { m_varVisitor(_var); }
-		void operator()(Label const& _label) const { m_labelVisitor(_label); }
-
-		std::function<void(Variable const&)> m_varVisitor;
-		std::function<void(Label const&)> m_labelVisitor;
-	};
-	struct NonconstVisitor: public boost::static_visitor<>
-	{
-		NonconstVisitor(
-			std::function<void(Variable&)> _varVisitor,
-			std::function<void(Label&)> _labelVisitor
-		):
-			m_varVisitor(std::move(_varVisitor)),
-			m_labelVisitor(std::move(_labelVisitor))
-		{}
-
-		void operator()(Variable& _var) const { m_varVisitor(_var); }
-		void operator()(Label& _label) const { m_labelVisitor(_label); }
-
-		std::function<void(Variable&)> m_varVisitor;
-		std::function<void(Label&)> m_labelVisitor;
-	};
-
-	bool registerLabel(std::string const& _name, size_t _id);
+	using Visitor = GenericVisitor<Variable const, Label const>;
+	using NonconstVisitor = GenericVisitor<Variable, Label>;
 
 	bool registerVariable(std::string const& _name);
+	bool registerLabel(std::string const& _name, size_t _id);
 
 	/// Looks up the identifier in this or super scopes and returns a valid pointer if
 	/// found or a nullptr if not found.
@@ -118,8 +111,6 @@ struct Scope
 			return false;
 	}
 
-
-
 	Scope* superScope = nullptr;
 	std::map<std::string, Identifier> identifiers;
 };
-- 
cgit 


From e963405a19c8435105df1fa48c9cdd92037b341f Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Thu, 16 Feb 2017 23:44:22 +0100
Subject: Partially add functions.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 36 ++++++++++++++++++++++++++++++++---
 libsolidity/inlineasm/AsmAnalysis.h   | 32 ++++++++++++++++++++++++-------
 libsolidity/inlineasm/AsmCodeGen.cpp  | 11 +++++++++++
 3 files changed, 69 insertions(+), 10 deletions(-)

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 133869ca..9e53fc4a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -38,7 +38,7 @@ using namespace dev::solidity::assembly;
 
 bool Scope::registerLabel(string const& _name, size_t _id)
 {
-	if (lookup(_name))
+	if (exists(_name))
 		return false;
 	identifiers[_name] = Scope::Label(_id);
 	return true;
@@ -47,22 +47,40 @@ bool Scope::registerLabel(string const& _name, size_t _id)
 
 bool Scope::registerVariable(string const& _name)
 {
-	if (lookup(_name))
+	if (exists(_name))
 		return false;
 	identifiers[_name] = Variable();
 	return true;
 }
 
+bool Scope::registerFunction(string const& _name, size_t _arguments, size_t _returns)
+{
+	if (exists(_name))
+		return false;
+	identifiers[_name] = Function(_arguments, _returns);
+	return true;
+}
+
 Scope::Identifier* Scope::lookup(string const& _name)
 {
 	if (identifiers.count(_name))
 		return &identifiers[_name];
-	else if (superScope)
+	else if (superScope && !closedScope)
 		return superScope->lookup(_name);
 	else
 		return nullptr;
 }
 
+bool Scope::exists(string const& _name)
+{
+	if (identifiers.count(_name))
+		return true;
+	else if (superScope)
+		return superScope->exists(_name);
+	else
+		return false;
+}
+
 AsmAnalyzer::AsmAnalyzer(AsmAnalyzer::Scopes& _scopes, ErrorList& _errors):
 	m_scopes(_scopes), m_errors(_errors)
 {
@@ -161,6 +179,18 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	return success;
 }
 
+bool AsmAnalyzer::operator()(assembly::FunctionDefinition const&)
+{
+	// TODO - we cannot throw an exception here because of some tests.
+	return true;
+}
+
+bool AsmAnalyzer::operator()(assembly::FunctionCall const&)
+{
+	// TODO - we cannot throw an exception here because of some tests.
+	return true;
+}
+
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index f00ad3d8..131bdee1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -43,6 +43,8 @@ struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
 struct Assignment;
+struct FunctionDefinition;
+struct FunctionCall;
 
 template <class...>
 struct GenericVisitor{};
@@ -87,18 +89,27 @@ struct Scope
 		static const size_t unassignedLabelId = 0;
 	};
 
-	using Identifier = boost::variant<Variable, Label>;
-	using Visitor = GenericVisitor<Variable const, Label const>;
-	using NonconstVisitor = GenericVisitor<Variable, Label>;
+	struct Function
+	{
+		Function(size_t _arguments, size_t _returns): arguments(_arguments), returns(_returns) {}
+		size_t arguments = 0;
+		size_t returns = 0;
+	};
+
+	using Identifier = boost::variant<Variable, Label, Function>;
+	using Visitor = GenericVisitor<Variable const, Label const, Function const>;
+	using NonconstVisitor = GenericVisitor<Variable, Label, Function>;
 
 	bool registerVariable(std::string const& _name);
 	bool registerLabel(std::string const& _name, size_t _id);
+	bool registerFunction(std::string const& _name, size_t _arguments, size_t _returns);
 
-	/// Looks up the identifier in this or super scopes and returns a valid pointer if
-	/// found or a nullptr if not found.
+	/// Looks up the identifier in this or super scopes (stops and function and assembly boundaries)
+	/// and returns a valid pointer if found or a nullptr if not found.
 	/// The pointer will be invalidated if the scope is modified.
 	Identifier* lookup(std::string const& _name);
-	/// Looks up the identifier in this and super scopes and calls the visitor, returns false if not found.
+	/// Looks up the identifier in this and super scopes (stops and function and assembly boundaries)
+	/// and calls the visitor, returns false if not found.
 	template <class V>
 	bool lookup(std::string const& _name, V const& _visitor)
 	{
@@ -110,8 +121,13 @@ struct Scope
 		else
 			return false;
 	}
-
+	/// @returns true if the name exists in this scope or in super scopes (also searches
+	/// across function and assembly boundaries).
+	bool exists(std::string const& _name);
 	Scope* superScope = nullptr;
+	/// If true, identifiers from the super scope are not visible here, but they are still
+	/// taken into account to prevent shadowing.
+	bool closedScope = false;
 	std::map<std::string, Identifier> identifiers;
 };
 
@@ -130,6 +146,8 @@ public:
 	bool operator()(assembly::Assignment const&) { return true; }
 	bool operator()(assembly::FunctionalAssignment const& _functionalAssignment);
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
+	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
+	bool operator()(assembly::FunctionCall const& _functionCall);
 	bool operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index c1efc72c..f168e765 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -153,6 +153,10 @@ public:
 				else if (_label.id == Scope::Label::errorLabelId)
 					_label.id = size_t(m_state.assembly.errorTag().data());
 				m_state.assembly.append(eth::AssemblyItem(eth::PushTag, _label.id));
+			},
+			[=](Scope::Function&)
+			{
+				solAssert(false, "Not yet implemented");
 			}
 		)))
 		{
@@ -259,6 +263,13 @@ private:
 					Error::Type::DeclarationError,
 					"Label \"" + string(_variableName.name) + "\" used as variable."
 				);
+			},
+			[=](Scope::Function const&)
+			{
+				m_state.addError(
+					Error::Type::DeclarationError,
+					"Function \"" + string(_variableName.name) + "\" used as variable."
+				);
 			}
 		)))
 		{
-- 
cgit 


From c85f9257f87bb8d6f84a4a74a9b290d7207eebd7 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Wed, 22 Feb 2017 18:57:31 +0100
Subject: Clarify stack height.

---
 docs/assembly.rst | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/docs/assembly.rst b/docs/assembly.rst
index b28216f1..cc2ad1c4 100644
--- a/docs/assembly.rst
+++ b/docs/assembly.rst
@@ -333,11 +333,12 @@ push their entry label (with virtual function resolution applied). The calling s
 in solidity are:
 
  - the caller pushes return label, arg1, arg2, ..., argn
- - the call returns with ret1, ret2, ..., retn
+ - the call returns with ret1, ret2, ..., retm
 
 This feature is still a bit cumbersome to use, because the stack offset essentially
 changes during the call, and thus references to local variables will be wrong.
-It is planned that the stack height changes can be specified in inline assembly.
+The assumed stack height can be changed by using labels: ``funreturn[-2]:``
+The number in brackets should be `m - n - 1`.
 
 .. code::
 
@@ -939,8 +940,16 @@ Pseudocode::
 Opcode Stream Generation
 ------------------------
 
-During opcode stream generation, we keep track of the current stack height,
-so that accessing stack variables by name is possible.
+During opcode stream generation, we keep track of the current stack height
+in a counter,
+so that accessing stack variables by name is possible. The stack height is modified with every opcode
+that modifies the stack and with every label that is annotated with a stack
+adjustment. Every time a new
+local variable is introduced, it is registered together with the current
+stack height. If a variable is accessed (either for copying its value or for
+assignment), the appropriate DUP or SWAP instruction is selected depending
+on the difference bitween the current stack height and the
+stack height at the point the variable was introduced.
 
 Pseudocode::
 
@@ -980,7 +989,7 @@ Pseudocode::
       POP
     LabelDefinition(name [id1, ..., idn] :) ->
       JUMPDEST
-      // register new variables id1, ..., idn and adjust the assumed stack
+      // register new local variables id1, ..., idn and adjust the stack
       // height such that it matches the stack height at the beginning of
       // the block plus all local variables including the just registered
       // ones where idn is at the stack top. If n is zero, resets the stack
-- 
cgit 


From 41236cd08c292dba428fa1ae57126fb4ec7e901d Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Thu, 23 Feb 2017 12:56:37 +0100
Subject: Slightly cleaner label ids.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 11 ++++++-----
 libsolidity/inlineasm/AsmAnalysis.h   |  5 ++---
 libsolidity/inlineasm/AsmCodeGen.cpp  | 21 ++++++++++++---------
 3 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 9e53fc4a..a21c50d1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -36,15 +36,14 @@ using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
 
-bool Scope::registerLabel(string const& _name, size_t _id)
+bool Scope::registerLabel(string const& _name)
 {
 	if (exists(_name))
 		return false;
-	identifiers[_name] = Scope::Label(_id);
+	identifiers[_name] = Label();
 	return true;
 }
 
-
 bool Scope::registerVariable(string const& _name)
 {
 	if (exists(_name))
@@ -86,7 +85,9 @@ AsmAnalyzer::AsmAnalyzer(AsmAnalyzer::Scopes& _scopes, ErrorList& _errors):
 {
 	// Make the Solidity ErrorTag available to inline assembly
 	m_scopes[nullptr] = make_shared<Scope>();
-	m_scopes[nullptr]->identifiers["invalidJumpLabel"] = Scope::Label(Scope::Label::errorLabelId);
+	Scope::Label errorLabel;
+	errorLabel.id = Scope::Label::errorLabelId;
+	m_scopes[nullptr]->identifiers["invalidJumpLabel"] = errorLabel;
 	m_currentScope = m_scopes[nullptr].get();
 }
 
@@ -116,7 +117,7 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 
 bool AsmAnalyzer::operator()(Label const& _item)
 {
-	if (!m_currentScope->registerLabel(_item.name, Scope::Label::unassignedLabelId))
+	if (!m_currentScope->registerLabel(_item.name))
 	{
 		//@TODO secondary location
 		m_errors.push_back(make_shared<Error>(
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 131bdee1..cd46cd73 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -81,8 +81,7 @@ struct Scope
 
 	struct Label
 	{
-		Label(size_t _id): id(_id) {}
-		size_t id = 0;
+		size_t id = unassignedLabelId;
 		int stackAdjustment = 0;
 		bool resetStackHeight = false;
 		static const size_t errorLabelId = -1;
@@ -101,7 +100,7 @@ struct Scope
 	using NonconstVisitor = GenericVisitor<Variable, Label, Function>;
 
 	bool registerVariable(std::string const& _name);
-	bool registerLabel(std::string const& _name, size_t _id);
+	bool registerLabel(std::string const& _name);
 	bool registerFunction(std::string const& _name, size_t _arguments, size_t _returns);
 
 	/// Looks up the identifier in this or super scopes (stops and function and assembly boundaries)
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index f168e765..bfa48c0e 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -148,10 +148,7 @@ public:
 			},
 			[=](Scope::Label& _label)
 			{
-				if (_label.id == Scope::Label::unassignedLabelId)
-					_label.id = m_state.newLabelId();
-				else if (_label.id == Scope::Label::errorLabelId)
-					_label.id = size_t(m_state.assembly.errorTag().data());
+				assignLabelIdIfUnset(_label);
 				m_state.assembly.append(eth::AssemblyItem(eth::PushTag, _label.id));
 			},
 			[=](Scope::Function&)
@@ -190,10 +187,7 @@ public:
 		m_state.assembly.setSourceLocation(_label.location);
 		solAssert(m_scope.identifiers.count(_label.name), "");
 		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers[_label.name]);
-		if (label.id == Scope::Label::unassignedLabelId)
-			label.id = m_state.newLabelId();
-		else if (label.id == Scope::Label::errorLabelId)
-			label.id = size_t(m_state.assembly.errorTag().data());
+		assignLabelIdIfUnset(label);
 		if (label.resetStackHeight)
 		{
 			size_t numVariables = boost::range::count_if(
@@ -318,6 +312,16 @@ private:
 			);
 	}
 
+	/// Assigns the label's id to a value taken from eth::Assembly if it has not yet been set.
+	void assignLabelIdIfUnset(Scope::Label& _label)
+	{
+		if (_label.id == Scope::Label::unassignedLabelId)
+			_label.id = m_state.newLabelId();
+		else if (_label.id == Scope::Label::errorLabelId)
+			_label.id = size_t(m_state.assembly.errorTag().data());
+	}
+
+
 	GeneratorState& m_state;
 	Scope& m_scope;
 	int const m_initialDeposit;
@@ -352,4 +356,3 @@ void assembly::CodeGenerator::assemble(eth::Assembly& _assembly, assembly::CodeG
 		solAssert(false, "Assembly error");
 	CodeTransform(state, m_parsedData, _identifierAccess);
 }
-
-- 
cgit 


From 455e8a4ef896984b7ce204a998a3392f191a7671 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Thu, 23 Feb 2017 17:38:42 +0100
Subject: Move lambda.

---
 libsolidity/analysis/TypeChecker.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 66f5de6a..10406400 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -592,8 +592,12 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 	// Inline assembly does not have its own type-checking phase, so we just run the
 	// code-generator and see whether it produces any errors.
 	// External references have already been resolved in a prior stage and stored in the annotation.
-	assembly::CodeGenerator codeGen(_inlineAssembly.operations(), m_errors);
-	if (!codeGen.typeCheck([&](assembly::Identifier const& _identifier, eth::Assembly& _assembly, assembly::CodeGenerator::IdentifierContext _context) {
+	auto identifierAccess = [&](
+		assembly::Identifier const& _identifier,
+		eth::Assembly& _assembly,
+		assembly::CodeGenerator::IdentifierContext _context
+	)
+	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
 		if (ref == _inlineAssembly.annotation().externalReferences.end())
 			return false;
@@ -641,7 +645,9 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 				return false;
 		}
 		return true;
-	}))
+	};
+	assembly::CodeGenerator codeGen(_inlineAssembly.operations(), m_errors);
+	if (!codeGen.typeCheck(identifierAccess))
 		return false;
 	return true;
 }
-- 
cgit 


From 13fd569f761154a4e4b4fe2c6431b056f04a9119 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Fri, 24 Feb 2017 17:42:41 +0100
Subject: First reset stack height, then register variables.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index bfa48c0e..69ce9507 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -194,19 +194,20 @@ public:
 				 m_scope.identifiers | boost::adaptors::map_values,
 				[](Scope::Identifier const& var) { return var.type() == typeid(Scope::Variable) && boost::get<Scope::Variable>(var).active; }
 			);
-			for (auto const& identifier: _label.stackInfo)
-				if (!identifier.empty())
-				{
-					solAssert(m_scope.identifiers.count(identifier), "");
-					Scope::Variable& var = boost::get<Scope::Variable>(m_scope.identifiers[identifier]);
-					var.active = true;
-					var.stackHeight = m_initialDeposit + numVariables;
-					numVariables++;
-				}
+			numVariables += boost::count_if(_label.stackInfo, [](string const& s) { return !s.empty(); });
 			m_state.assembly.setDeposit(m_initialDeposit + numVariables);
 		}
 		else if (label.stackAdjustment != 0)
 			m_state.assembly.adjustDeposit(label.stackAdjustment);
+		int height = m_state.assembly.deposit();
+		for (auto const& identifier: _label.stackInfo | boost::adaptors::reversed)
+			if (!identifier.empty())
+			{
+				solAssert(m_scope.identifiers.count(identifier), "");
+				Scope::Variable& var = boost::get<Scope::Variable>(m_scope.identifiers[identifier]);
+				var.active = true;
+				var.stackHeight = --height;
+			}
 		m_state.assembly.append(eth::AssemblyItem(eth::Tag, label.id));
 	}
 	void operator()(assembly::Assignment const& _assignment)
-- 
cgit 


From 369005fc03f13a392abef4b0a8b23226c796d023 Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Tue, 28 Feb 2017 10:46:09 +0100
Subject: Remove stack annotations again.

---
 libsolidity/inlineasm/AsmAnalysis.cpp     | 31 +-------------------------
 libsolidity/inlineasm/AsmAnalysis.h       |  2 --
 libsolidity/inlineasm/AsmCodeGen.cpp      | 20 -----------------
 libsolidity/inlineasm/AsmData.h           |  4 ++--
 libsolidity/inlineasm/AsmParser.cpp       | 36 -------------------------------
 libsolidity/inlineasm/AsmPrinter.cpp      |  6 +-----
 test/libsolidity/InlineAssembly.cpp       | 10 ---------
 test/libsolidity/SolidityEndToEndTest.cpp | 27 -----------------------
 8 files changed, 4 insertions(+), 132 deletions(-)

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index a21c50d1..4296d3a7 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -127,36 +127,7 @@ bool AsmAnalyzer::operator()(Label const& _item)
 		));
 		return false;
 	}
-	bool success = true;
-	if (!_item.stackInfo.empty())
-	{
-		Scope::Label& label = boost::get<Scope::Label>(m_currentScope->identifiers[_item.name]);
-		if (_item.stackInfo.size() == 1)
-			try
-			{
-				label.stackAdjustment = boost::lexical_cast<int>(_item.stackInfo[0]);
-				label.resetStackHeight = false;
-				return true;
-			}
-			catch (boost::bad_lexical_cast const&)
-			{
-				// Interpret as variable name
-			}
-		label.resetStackHeight = true;
-		for (auto const& stackItem: _item.stackInfo)
-			if (!stackItem.empty())
-				if (!m_currentScope->registerVariable(stackItem))
-				{
-					//@TODO secondary location
-					m_errors.push_back(make_shared<Error>(
-						Error::Type::DeclarationError,
-						"Variable name " + stackItem + " already taken in this scope.",
-						_item.location
-					));
-					success = false;
-				}
-	}
-	return success;
+	return true;
 }
 
 bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index cd46cd73..9726210d 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -82,8 +82,6 @@ struct Scope
 	struct Label
 	{
 		size_t id = unassignedLabelId;
-		int stackAdjustment = 0;
-		bool resetStackHeight = false;
 		static const size_t errorLabelId = -1;
 		static const size_t unassignedLabelId = 0;
 	};
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 69ce9507..78a9ee27 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -188,26 +188,6 @@ public:
 		solAssert(m_scope.identifiers.count(_label.name), "");
 		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers[_label.name]);
 		assignLabelIdIfUnset(label);
-		if (label.resetStackHeight)
-		{
-			size_t numVariables = boost::range::count_if(
-				 m_scope.identifiers | boost::adaptors::map_values,
-				[](Scope::Identifier const& var) { return var.type() == typeid(Scope::Variable) && boost::get<Scope::Variable>(var).active; }
-			);
-			numVariables += boost::count_if(_label.stackInfo, [](string const& s) { return !s.empty(); });
-			m_state.assembly.setDeposit(m_initialDeposit + numVariables);
-		}
-		else if (label.stackAdjustment != 0)
-			m_state.assembly.adjustDeposit(label.stackAdjustment);
-		int height = m_state.assembly.deposit();
-		for (auto const& identifier: _label.stackInfo | boost::adaptors::reversed)
-			if (!identifier.empty())
-			{
-				solAssert(m_scope.identifiers.count(identifier), "");
-				Scope::Variable& var = boost::get<Scope::Variable>(m_scope.identifiers[identifier]);
-				var.active = true;
-				var.stackHeight = --height;
-			}
 		m_state.assembly.append(eth::AssemblyItem(eth::Tag, label.id));
 	}
 	void operator()(assembly::Assignment const& _assignment)
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 5969bf96..d61b5803 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -42,8 +42,8 @@ struct Literal { SourceLocation location; bool isNumber; std::string value; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
-/// Jump label ("name:" or "name [x, y, z]:" or "name [-3]:")
-struct Label { SourceLocation location; std::string name; std::vector<std::string> stackInfo; };
+/// Jump label ("name:")
+struct Label { SourceLocation location; std::string name; };
 /// Assignemnt (":= x", moves stack top into x, potentially multiple slots)
 struct Assignment { SourceLocation location; Identifier variableName; };
 struct FunctionalAssignment;
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 9f24d9fb..0fc0a34f 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -121,42 +121,6 @@ assembly::Statement Parser::parseStatement()
 			return label;
 		}
 	}
-	case Token::LBrack:
-	{
-		if (statement.type() != typeid(assembly::Identifier))
-			fatalParserError("Label name must precede \"[\".");
-		assembly::Identifier const& identifier = boost::get<assembly::Identifier>(statement);
-		Label label = createWithLocation<Label>(identifier.location);
-		label.name = identifier.name;
-		m_scanner->next();
-		if (m_scanner->currentToken() == Token::Number)
-		{
-			label.stackInfo.push_back(m_scanner->currentLiteral());
-			m_scanner->next();
-		}
-		else if (m_scanner->currentToken() == Token::Sub)
-		{
-			m_scanner->next();
-			label.stackInfo.push_back("-" + m_scanner->currentLiteral());
-			expectToken(Token::Number);
-		}
-		else if (m_scanner->currentToken() != Token::RBrack)
-			while (true)
-			{
-				label.stackInfo.push_back(expectAsmIdentifier());
-				if (m_scanner->currentToken() == Token::RBrack)
-					break;
-				expectToken(Token::Comma);
-			}
-		// Push an empty string to signify that there were brackets, like in
-		// "name[]:", which just resets the stack height to the height of the local variables.
-		if (label.stackInfo.empty())
-			label.stackInfo.push_back("");
-		expectToken(Token::RBrack);
-		label.location.end = endPosition();
-		expectToken(Token::Colon);
-		return label;
-	}
 	default:
 		break;
 	}
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 5ec83281..a70b0b78 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -94,11 +94,7 @@ string AsmPrinter::operator()(assembly::FunctionalInstruction const& _functional
 
 string AsmPrinter::operator()(assembly::Label const& _label)
 {
-	return _label.name + (
-		!_label.stackInfo.empty() ?
-		"[" +  boost::algorithm::join(_label.stackInfo, ", ") + "]" :
-		string()
-	) + ":";
+	return _label.name + ":";
 }
 
 string AsmPrinter::operator()(assembly::Assignment const& _assignment)
diff --git a/test/libsolidity/InlineAssembly.cpp b/test/libsolidity/InlineAssembly.cpp
index 824fce95..9035599b 100644
--- a/test/libsolidity/InlineAssembly.cpp
+++ b/test/libsolidity/InlineAssembly.cpp
@@ -200,11 +200,6 @@ BOOST_AUTO_TEST_CASE(blocks)
 	BOOST_CHECK(successParse("{ let x := 7 { let y := 3 } { let z := 2 } }"));
 }
 
-BOOST_AUTO_TEST_CASE(labels_with_stack_info)
-{
-	BOOST_CHECK(successParse("{ x[-1]: y[a]: z[d, e]: h[100]: g[]: }"));
-}
-
 BOOST_AUTO_TEST_CASE(function_definitions)
 {
 	BOOST_CHECK(successParse("{ function f() { } function g(a) -> (x) { } }"));
@@ -249,11 +244,6 @@ BOOST_AUTO_TEST_CASE(print_label)
 	parsePrintCompare("{\n    loop:\n    jump(loop)\n}");
 }
 
-BOOST_AUTO_TEST_CASE(print_label_with_stack)
-{
-	parsePrintCompare("{\n    loop[x, y]:\n    other[-2]:\n    third[10]:\n}");
-}
-
 BOOST_AUTO_TEST_CASE(print_assignments)
 {
 	parsePrintCompare("{\n    let x := mul(2, 3)\n    7\n    =: x\n    x := add(1, 2)\n}");
diff --git a/test/libsolidity/SolidityEndToEndTest.cpp b/test/libsolidity/SolidityEndToEndTest.cpp
index d2028344..cb0cc168 100644
--- a/test/libsolidity/SolidityEndToEndTest.cpp
+++ b/test/libsolidity/SolidityEndToEndTest.cpp
@@ -7418,33 +7418,6 @@ BOOST_AUTO_TEST_CASE(inline_assembly_function_access)
 	BOOST_CHECK(callContractFunction("x()") == encodeArgs(u256(10)));
 }
 
-BOOST_AUTO_TEST_CASE(inline_assembly_labels_with_stack_info)
-{
-	char const* sourceCode = R"(
-		contract C {
-			function f(uint y) {
-				assembly {
-					y 7
-					jump(fun)
-					exit[-1]:
-					y add
-					0 mstore
-					return(0, 0x20)
-					fun:
-					{
-						entry[a, b]:
-						a := div(a, b)
-						pop
-						jump(exit)
-					}
-				}
-			}
-		}
-	)";
-	compileAndRun(sourceCode, 0, "C");
-	BOOST_CHECK(callContractFunction("f(uint256)", u256(15)) == encodeArgs(15 / 7 + 15));
-}
-
 BOOST_AUTO_TEST_CASE(index_access_with_type_conversion)
 {
 	// Test for a bug where higher order bits cleanup was not done for array index access.
-- 
cgit 


From 8c1d949d1a5aaa4f78ee54ddafd20f245fd95d3a Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Tue, 28 Feb 2017 11:12:58 +0100
Subject: Remove stack annotations from documentation.

---
 docs/assembly.rst | 106 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 58 insertions(+), 48 deletions(-)

diff --git a/docs/assembly.rst b/docs/assembly.rst
index cc2ad1c4..415bb1a1 100644
--- a/docs/assembly.rst
+++ b/docs/assembly.rst
@@ -337,8 +337,6 @@ in solidity are:
 
 This feature is still a bit cumbersome to use, because the stack offset essentially
 changes during the call, and thus references to local variables will be wrong.
-The assumed stack height can be changed by using labels: ``funreturn[-2]:``
-The number in brackets should be `m - n - 1`.
 
 .. code::
 
@@ -415,19 +413,23 @@ to the stack height just prior to the label.
 Note that you will not have to care about these things if you just use
 loops and assembly-level functions.
 
+As an example how this can be done in extreme cases, please see the following.
+
 .. code::
 
     {
         let x := 8
         jump(two)
-        one[1]:
-            // Now the stack height is correctly adjusted.
-            x := 9
+        0 // This code is unreachable but will adjust the stack height correctly
+        one:
+            x := 9 // Now x can be accessed properly.
             jump(three)
+            pop // Similar negative correction.
         two:
             7 // push something onto the stack
             jump(one)
         three:
+        pop // We have to pop the manually pushed value here again.
     }
 
 .. note::
@@ -652,17 +654,12 @@ for e.g. returning runtime code or creating contracts. No identifier from an
 outer assembly is visible in a sub-assembly.
 
 If control flow passes over the end of a block, pop instructions are inserted
-that match the number of local variables declared in that block, unless the
-``}`` is directly preceded by an opcode that does not have a continuing control
-flow path. Whenever a local variable is referenced, the code generator needs
+that match the number of local variables declared in that block.
+Whenever a local variable is referenced, the code generator needs
 to know its current relative position in the stack and thus it needs to
-keep track of the current so-called stack height.
-At the end of a block, this implicit stack height is always reduced by the number
-of local variables whether there is a continuing control flow or not.
-
-This means that the stack height before and after the block should be the same.
-If this is not the case, a warning is issued,
-unless the last instruction in the block did not have a continuing control flow path.
+keep track of the current so-called stack height. Since all local variables
+are removed at the end of a block, the stack height before and after the block
+should be the same. If this is not the case, a warning is issued.
 
 Why do we use higher-level constructs like ``switch``, ``for`` and functions:
 
@@ -674,10 +671,9 @@ verification and optimization.
 Furthermore, if manual jumps are allowed, computing the stack height is rather complicated.
 The position of all local variables on the stack needs to be known, otherwise
 neither references to local variables nor removing local variables automatically
-from the stack at the end of a block will work properly. Because of that,
-every label that is preceded by an instruction that ends or diverts control flow
-should be annotated with the current stack layout. This annotation is performed
-automatically during the desugaring phase.
+from the stack at the end of a block will work properly. The desugaring
+mechanism correctly inserts operations at unreachable blocks that adjust the
+stack height properly in case of jumps that do not have a continuing control flow.
 
 Example:
 
@@ -730,17 +726,21 @@ After the desugaring phase it looks as follows::
         $case1:
         {
           // the function call - we put return label and arguments on the stack
-          $ret1 calldataload(4) jump($fun_f)
-          $ret1 [r]: // a label with a [...]-annotation resets the stack height
-                    // to "current block + number of local variables". It also
-                    // introduces a variable, r:
-                    // r is at top of stack, $0 is below (from enclosing block)
-          $ret2 0x20 jump($fun_allocate)
-          $ret2 [ret]: // stack here: $0, r, ret (top)
+          $ret1 calldataload(4) jump(f)
+          // This is unreachable code. Opcodes are added that mirror the
+          // effect of the function on the stack height: Arguments are
+          // removed and return values are introduced.
+          pop pop
+          let r := 0
+          $ret1: // the actual return point
+          $ret2 0x20 jump($allocate)
+          pop pop let ret := 0
+          $ret2:
           mstore(ret, r)
           return(ret, 0x20)
           // although it is useless, the jump is automatically inserted,
-          // since the desugaring process does not analyze control-flow
+          // since the desugaring process is a purely syntactic operation that
+          // does not analyze control-flow
           jump($endswitch)
         }
         $caseDefault:
@@ -751,20 +751,29 @@ After the desugaring phase it looks as follows::
         $endswitch:
       }
       jump($afterFunction)
-      $fun_allocate:
+      allocate:
       {
-        $start[$retpos, size]:
-        // output variables live in the same scope as the arguments.
+        // we jump over the unreachable code that introduces the function arguments
+        jump($start)
+        let $retpos := 0 let size := 0
+        $start:
+        // output variables live in the same scope as the arguments and is
+        // actually allocated.
         let pos := 0
         {
           pos := mload(0x40)
           mstore(0x40, add(pos, size))
         }
+        // This code replaces the arguments by the return values and jumps back.
         swap1 pop swap1 jump
+        // Again unreachable code that corrects stack height.
+        0 0
       }
-      $fun_f:
+      f:
       {
-        start [$retpos, x]:
+        jump($start)
+        let $retpos := 0 let x := 0
+        $start:
         let y := 0
         {
           let i := 0
@@ -777,8 +786,9 @@ After the desugaring phase it looks as follows::
           { i := add(i, 1) }
           jump($for_begin)
           $for_end:
-        } // Here, a pop instruction is inserted for i
+        } // Here, a pop instruction will be inserted for i
         swap1 pop swap1 jump
+        0 0
       }
       $afterFunction:
       stop
@@ -839,7 +849,7 @@ Grammar::
     IdentifierOrList = Identifier | '(' IdentifierList ')'
     IdentifierList = Identifier ( ',' Identifier)*
     AssemblyAssignment = '=:' Identifier
-    LabelDefinition = Identifier ( '[' ( IdentifierList? | NumberLiteral ) ']' )? ':'
+    LabelDefinition = Identifier ':'
     AssemblySwitch = 'switch' FunctionalAssemblyExpression AssemblyCase*
         ( 'default' ':' AssemblyBlock )?
     AssemblyCase = 'case' FunctionalAssemblyExpression ':' AssemblyBlock
@@ -872,11 +882,14 @@ Pseudocode::
     AssemblyFunctionDefinition('function' name '(' arg1, ..., argn ')' '->' ( '(' ret1, ..., retm ')' body) ->
       <name>:
       {
-        $<name>_start [$retPC, $argn, ..., arg1]:
+        jump($<name>_start)
+        let $retPC := 0 let argn := 0 ... let arg1 := 0
+        $<name>_start:
         let ret1 := 0 ... let retm := 0
         { desugar(body) }
-        swap and pop items so that only ret1, ... retn, $retPC are left on the stack
-        jump 
+        swap and pop items so that only ret1, ... retm, $retPC are left on the stack
+        jump
+        0 (1 + n times) to compensate removal of arg1, ..., argn and $retPC
       }
     AssemblyFor('for' { init } condition post body) ->
       {
@@ -896,6 +909,7 @@ Pseudocode::
         pop all local variables that are defined at the current point
         but not at $forI_end
         jump($forI_end)
+        0 (as many as variables were removed above)
       }
     'continue' ->
       {
@@ -903,6 +917,7 @@ Pseudocode::
         pop all local variables that are defined at the current point
         but not at $forI_continue
         jump($forI_continue)
+        0 (as many as variables were removed above)
       }
     AssemblySwitch(switch condition cases ( default: defaultBlock )? ) ->
       {
@@ -924,10 +939,13 @@ Pseudocode::
           {
             // find I such that $funcallI_* does not exist
             $funcallI_return argn  ... arg2 arg1 jump(<name>)
+            pop (n + 1 times)
             if the current context is `let (id1, ..., idm) := f(...)` ->
-              $funcallI_return [id1, ..., idm]:
+              let id1 := 0 ... let idm := 0
+              $funcallI_return:
             else ->
-              $funcallI_return[m - n - 1]:
+              0 (m times)
+              $funcallI_return:
               turn the functional expression that leads to the function call
               into a statement stream
           }
@@ -987,16 +1005,8 @@ Pseudocode::
       look up id in the syntactic stack of blocks, assert that it is a variable
       SWAPi where i = 1 + stack_height - stack_height_of_identifier(id)
       POP
-    LabelDefinition(name [id1, ..., idn] :) ->
-      JUMPDEST
-      // register new local variables id1, ..., idn and adjust the stack
-      // height such that it matches the stack height at the beginning of
-      // the block plus all local variables including the just registered
-      // ones where idn is at the stack top. If n is zero, resets the stack
-      // height to just the local variables.
-    LabelDefinition(name [number] :) ->
+    LabelDefinition(name:) ->
       JUMPDEST
-      // adjust stack height by the relative amount "number" (can be negative)
     NumberLiteral(num) ->
       PUSH<num interpreted as decimal and right-aligned>
     HexLiteral(lit) ->
-- 
cgit 


From f8ce32f2a6899a7026a754b44c4b68d009e1742e Mon Sep 17 00:00:00 2001
From: chriseth <c@ethdev.com>
Date: Fri, 3 Mar 2017 15:40:52 +0100
Subject: Fix error message.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 4296d3a7..a3ddb61d 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -97,7 +97,7 @@ bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 	{
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
-			"string literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)"
+			"String literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)"
 		));
 		return false;
 	}
-- 
cgit