From 1367f89b84090361faca05768d2257e7a5072e41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Bylica?= <pawel.bylica@imapp.pl>
Date: Wed, 15 Oct 2014 19:27:42 +0200
Subject: [PATCH] Basic block compilation in separated function

---
 evmcc/Compiler.cpp | 1200 ++++++++++++++++++++++----------------------
 evmcc/Compiler.h   |    2 +
 2 files changed, 604 insertions(+), 598 deletions(-)

diff --git a/evmcc/Compiler.cpp b/evmcc/Compiler.cpp
index 71ad61493..d5d4e6816 100644
--- a/evmcc/Compiler.cpp
+++ b/evmcc/Compiler.cpp
@@ -172,706 +172,710 @@ std::unique_ptr<llvm::Module> Compiler::compile(const bytes& bytecode)
 	for (auto basicBlockPairIt = basicBlocks.begin(); basicBlockPairIt != basicBlocks.end(); ++basicBlockPairIt)
 	{
 		auto& basicBlock = basicBlockPairIt->second;
-		auto& stack = basicBlock.getStack();
-		m_builder.SetInsertPoint(basicBlock);
+		auto iterCopy = basicBlockPairIt;
+		++iterCopy;
+		auto nextBasicBlock = (iterCopy != basicBlocks.end()) ? iterCopy->second.llvm() : nullptr;
+		compileBasicBlock(basicBlock, bytecode, memory, ext, gasMeter, nextBasicBlock);
+	}
+
+	// Code for special blocks:
+	// TODO: move to separate function.
+	// Note: Right now the codegen for special blocks depends only on createBasicBlock(),
+	// not on the codegen for 'regular' blocks. But it has to be done before linkBasicBlocks().
+	m_builder.SetInsertPoint(m_stopBB);
+	m_builder.CreateRet(Constant::get(ReturnCode::Stop));
 
-		for (auto currentPC = basicBlock.begin(); currentPC != basicBlock.end(); ++currentPC)
+	m_builder.SetInsertPoint(m_badJumpBlock->llvm());
+	m_builder.CreateRet(Constant::get(ReturnCode::BadJumpDestination));
+
+	m_builder.SetInsertPoint(m_jumpTableBlock->llvm());
+	if (m_indirectJumpTargets.size() > 0)
+	{
+		auto& stack = m_jumpTableBlock->getStack();
+
+		auto dest = stack.pop();
+		auto switchInstr = 	m_builder.CreateSwitch(dest, m_badJumpBlock->llvm(),
+		                   	                     m_indirectJumpTargets.size());
+		for (auto it = m_indirectJumpTargets.cbegin(); it != m_indirectJumpTargets.cend(); ++it)
 		{
-			auto inst = static_cast<Instruction>(bytecode[currentPC]);
+			auto& bb = *it;
+			auto dest = Constant::get(bb->begin());
+			switchInstr->addCase(dest, bb->llvm());
+		}
+	}
+	else
+	{
+		m_builder.CreateBr(m_badJumpBlock->llvm());
+	}
 
-			gasMeter.count(inst);
+	linkBasicBlocks();
 
-			switch (inst)
-			{
+	return module;
+}
 
-			case Instruction::ADD:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto result = m_builder.CreateAdd(lhs, rhs);
-				stack.push(result);
-				break;
-			}
 
-			case Instruction::SUB:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto result = m_builder.CreateSub(lhs, rhs);
-				stack.push(result);
-				break;
-			}
+void Compiler::compileBasicBlock(BasicBlock& basicBlock, const bytes& bytecode, Memory& memory, Ext& ext, GasMeter& gasMeter, llvm::BasicBlock* nextBasicBlock)
+{
+	auto& stack = basicBlock.getStack();
+	m_builder.SetInsertPoint(basicBlock.llvm());
 
-			case Instruction::MUL:
-			{
-				auto lhs256 = stack.pop();
-				auto rhs256 = stack.pop();
-				auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
-				auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
-				auto res128 = m_builder.CreateMul(lhs128, rhs128);
-				auto res256 = m_builder.CreateZExt(res128, Type::i256);
-				stack.push(res256);
-				break;
-			}
+	for (auto currentPC = basicBlock.begin(); currentPC != basicBlock.end(); ++currentPC)
+	{
+		auto inst = static_cast<Instruction>(bytecode[currentPC]);
 
-			case Instruction::DIV:
-			{
-				auto lhs256 = stack.pop();
-				auto rhs256 = stack.pop();
-				auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
-				auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
-				auto res128 = m_builder.CreateUDiv(lhs128, rhs128);
-				auto res256 = m_builder.CreateZExt(res128, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		gasMeter.count(inst);
 
-			case Instruction::SDIV:
-			{
-				auto lhs256 = stack.pop();
-				auto rhs256 = stack.pop();
-				auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
-				auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
-				auto res128 = m_builder.CreateSDiv(lhs128, rhs128);
-				auto res256 = m_builder.CreateSExt(res128, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		switch (inst)
+		{
 
-			case Instruction::MOD:
-			{
-				auto lhs256 = stack.pop();
-				auto rhs256 = stack.pop();
-				auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
-				auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
-				auto res128 = m_builder.CreateURem(lhs128, rhs128);
-				auto res256 = m_builder.CreateZExt(res128, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::ADD:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto result = m_builder.CreateAdd(lhs, rhs);
+			stack.push(result);
+			break;
+		}
 
-			case Instruction::SMOD:
-			{
-				auto lhs256 = stack.pop();
-				auto rhs256 = stack.pop();
-				auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
-				auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
-				auto res128 = m_builder.CreateSRem(lhs128, rhs128);
-				auto res256 = m_builder.CreateSExt(res128, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::SUB:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto result = m_builder.CreateSub(lhs, rhs);
+			stack.push(result);
+			break;
+		}
 
-			case Instruction::EXP:
-			{
-				auto left = stack.pop();
-				auto right = stack.pop();
-				auto ret = ext.exp(left, right);
-				stack.push(ret);
-				break;
-			}
+		case Instruction::MUL:
+		{
+			auto lhs256 = stack.pop();
+			auto rhs256 = stack.pop();
+			auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
+			auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
+			auto res128 = m_builder.CreateMul(lhs128, rhs128);
+			auto res256 = m_builder.CreateZExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::NEG:
-			{
-				auto top = stack.pop();
-				auto zero = Constant::get(0);
-				auto res = m_builder.CreateSub(zero, top);
-				stack.push(res);
-				break;
-			}
+		case Instruction::DIV:
+		{
+			auto lhs256 = stack.pop();
+			auto rhs256 = stack.pop();
+			auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
+			auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
+			auto res128 = m_builder.CreateUDiv(lhs128, rhs128);
+			auto res256 = m_builder.CreateZExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::LT:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res1 = m_builder.CreateICmpULT(lhs, rhs);
-				auto res256 = m_builder.CreateZExt(res1, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::SDIV:
+		{
+			auto lhs256 = stack.pop();
+			auto rhs256 = stack.pop();
+			auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
+			auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
+			auto res128 = m_builder.CreateSDiv(lhs128, rhs128);
+			auto res256 = m_builder.CreateSExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::GT:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res1 = m_builder.CreateICmpUGT(lhs, rhs);
-				auto res256 = m_builder.CreateZExt(res1, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::MOD:
+		{
+			auto lhs256 = stack.pop();
+			auto rhs256 = stack.pop();
+			auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
+			auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
+			auto res128 = m_builder.CreateURem(lhs128, rhs128);
+			auto res256 = m_builder.CreateZExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::SLT:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res1 = m_builder.CreateICmpSLT(lhs, rhs);
-				auto res256 = m_builder.CreateZExt(res1, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::SMOD:
+		{
+			auto lhs256 = stack.pop();
+			auto rhs256 = stack.pop();
+			auto lhs128 = m_builder.CreateTrunc(lhs256, Type::lowPrecision);
+			auto rhs128 = m_builder.CreateTrunc(rhs256, Type::lowPrecision);
+			auto res128 = m_builder.CreateSRem(lhs128, rhs128);
+			auto res256 = m_builder.CreateSExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::SGT:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res1 = m_builder.CreateICmpSGT(lhs, rhs);
-				auto res256 = m_builder.CreateZExt(res1, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::EXP:
+		{
+			auto left = stack.pop();
+			auto right = stack.pop();
+			auto ret = ext.exp(left, right);
+			stack.push(ret);
+			break;
+		}
 
-			case Instruction::EQ:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res1 = m_builder.CreateICmpEQ(lhs, rhs);
-				auto res256 = m_builder.CreateZExt(res1, Type::i256);
-				stack.push(res256);
-				break;
-			}
+		case Instruction::NEG:
+		{
+			auto top = stack.pop();
+			auto zero = Constant::get(0);
+			auto res = m_builder.CreateSub(zero, top);
+			stack.push(res);
+			break;
+		}
 
-			case Instruction::NOT:
-			{
-				auto top = stack.pop();
-				auto iszero = m_builder.CreateICmpEQ(top, Constant::get(0), "iszero");
-				auto result = m_builder.CreateZExt(iszero, Type::i256);
-				stack.push(result);
-				break;
-			}
+		case Instruction::LT:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res1 = m_builder.CreateICmpULT(lhs, rhs);
+			auto res256 = m_builder.CreateZExt(res1, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::AND:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res = m_builder.CreateAnd(lhs, rhs);
-				stack.push(res);
-				break;
-			}
+		case Instruction::GT:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res1 = m_builder.CreateICmpUGT(lhs, rhs);
+			auto res256 = m_builder.CreateZExt(res1, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::OR:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res = m_builder.CreateOr(lhs, rhs);
-				stack.push(res);
-				break;
-			}
+		case Instruction::SLT:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res1 = m_builder.CreateICmpSLT(lhs, rhs);
+			auto res256 = m_builder.CreateZExt(res1, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::XOR:
-			{
-				auto lhs = stack.pop();
-				auto rhs = stack.pop();
-				auto res = m_builder.CreateXor(lhs, rhs);
-				stack.push(res);
-				break;
-			}
+		case Instruction::SGT:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res1 = m_builder.CreateICmpSGT(lhs, rhs);
+			auto res256 = m_builder.CreateZExt(res1, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::BYTE:
-			{
-				const auto byteNum = stack.pop();
-				auto value = stack.pop();
+		case Instruction::EQ:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res1 = m_builder.CreateICmpEQ(lhs, rhs);
+			auto res256 = m_builder.CreateZExt(res1, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-				/*
-				if (byteNum < 32)	- use select
-				{
-				value <<= byteNum*8
-				value >>= 31*8
-				push value
-				}
-				else push 0
-				*/
+		case Instruction::NOT:
+		{
+			auto top = stack.pop();
+			auto iszero = m_builder.CreateICmpEQ(top, Constant::get(0), "iszero");
+			auto result = m_builder.CreateZExt(iszero, Type::i256);
+			stack.push(result);
+			break;
+		}
 
-				// TODO: Shifting by 0 gives wrong results as of this bug http://llvm.org/bugs/show_bug.cgi?id=16439
+		case Instruction::AND:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res = m_builder.CreateAnd(lhs, rhs);
+			stack.push(res);
+			break;
+		}
 
-				auto shbits = m_builder.CreateShl(byteNum, Constant::get(3));
-				value = m_builder.CreateShl(value, shbits);
-				value = m_builder.CreateLShr(value, Constant::get(31 * 8));
+		case Instruction::OR:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res = m_builder.CreateOr(lhs, rhs);
+			stack.push(res);
+			break;
+		}
 
-				auto byteNumValid = m_builder.CreateICmpULT(byteNum, Constant::get(32));
-				value = m_builder.CreateSelect(byteNumValid, value, Constant::get(0));
-				stack.push(value);
+		case Instruction::XOR:
+		{
+			auto lhs = stack.pop();
+			auto rhs = stack.pop();
+			auto res = m_builder.CreateXor(lhs, rhs);
+			stack.push(res);
+			break;
+		}
 
-				break;
-			}
+		case Instruction::BYTE:
+		{
+			const auto byteNum = stack.pop();
+			auto value = stack.pop();
 
-			case Instruction::ADDMOD:
+			/*
+			if (byteNum < 32)	- use select
 			{
-				auto val1 = stack.pop();
-				auto val2 = stack.pop();
-				auto sum = m_builder.CreateAdd(val1, val2);
-				auto mod = stack.pop();
-
-				auto sum128 = m_builder.CreateTrunc(sum, Type::lowPrecision);
-				auto mod128 = m_builder.CreateTrunc(mod, Type::lowPrecision);
-				auto res128 = m_builder.CreateURem(sum128, mod128);
-				auto res256 = m_builder.CreateZExt(res128, Type::i256);
-				stack.push(res256);
-				break;
+			value <<= byteNum*8
+			value >>= 31*8
+			push value
 			}
+			else push 0
+			*/
 
-			case Instruction::MULMOD:
-			{
-				auto val1 = stack.pop();
-				auto val2 = stack.pop();
-				auto prod = m_builder.CreateMul(val1, val2);
-				auto mod = stack.pop();
-
-				auto prod128 = m_builder.CreateTrunc(prod, Type::lowPrecision);
-				auto mod128 = m_builder.CreateTrunc(mod, Type::lowPrecision);
-				auto res128 = m_builder.CreateURem(prod128, mod128);
-				auto res256 = m_builder.CreateZExt(res128, Type::i256);
-				stack.push(res256);
-				break;
-			}
+			// TODO: Shifting by 0 gives wrong results as of this bug http://llvm.org/bugs/show_bug.cgi?id=16439
 
-			case Instruction::SHA3:
-			{
-				auto inOff = stack.pop();
-				auto inSize = stack.pop();
-				memory.require(inOff, inSize);
-				auto hash = ext.sha3(inOff, inSize);
-				stack.push(hash);
-			}
+			auto shbits = m_builder.CreateShl(byteNum, Constant::get(3));
+			value = m_builder.CreateShl(value, shbits);
+			value = m_builder.CreateLShr(value, Constant::get(31 * 8));
 
-			case Instruction::POP:
-			{
-				stack.pop();
-				break;
-			}
+			auto byteNumValid = m_builder.CreateICmpULT(byteNum, Constant::get(32));
+			value = m_builder.CreateSelect(byteNumValid, value, Constant::get(0));
+			stack.push(value);
 
-			case Instruction::ANY_PUSH:
-			{
-				auto numBytes = static_cast<size_t>(inst)-static_cast<size_t>(Instruction::PUSH1) + 1;
-				auto value = llvm::APInt(256, 0);
-				for (decltype(numBytes) i = 0; i < numBytes; ++i)	// TODO: Use pc as iterator
-				{
-					++currentPC;
-					value <<= 8;
-					value |= bytecode[currentPC];
-				}
-				auto c = m_builder.getInt(value);
-				stack.push(c);
-				break;
-			}
+			break;
+		}
 
-			case Instruction::ANY_DUP:
-			{
-				auto index = static_cast<size_t>(inst)-static_cast<size_t>(Instruction::DUP1);
-				stack.dup(index);
-				break;
-			}
+		case Instruction::ADDMOD:
+		{
+			auto val1 = stack.pop();
+			auto val2 = stack.pop();
+			auto sum = m_builder.CreateAdd(val1, val2);
+			auto mod = stack.pop();
+
+			auto sum128 = m_builder.CreateTrunc(sum, Type::lowPrecision);
+			auto mod128 = m_builder.CreateTrunc(mod, Type::lowPrecision);
+			auto res128 = m_builder.CreateURem(sum128, mod128);
+			auto res256 = m_builder.CreateZExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::ANY_SWAP:
-			{
-				auto index = static_cast<size_t>(inst)-static_cast<size_t>(Instruction::SWAP1) + 1;
-				stack.swap(index);
-				break;
-			}
+		case Instruction::MULMOD:
+		{
+			auto val1 = stack.pop();
+			auto val2 = stack.pop();
+			auto prod = m_builder.CreateMul(val1, val2);
+			auto mod = stack.pop();
+
+			auto prod128 = m_builder.CreateTrunc(prod, Type::lowPrecision);
+			auto mod128 = m_builder.CreateTrunc(mod, Type::lowPrecision);
+			auto res128 = m_builder.CreateURem(prod128, mod128);
+			auto res256 = m_builder.CreateZExt(res128, Type::i256);
+			stack.push(res256);
+			break;
+		}
 
-			case Instruction::MLOAD:
-			{
-				auto addr = stack.pop();
-				auto word = memory.loadWord(addr);
-				stack.push(word);
-				break;
-			}
+		case Instruction::SHA3:
+		{
+			auto inOff = stack.pop();
+			auto inSize = stack.pop();
+			memory.require(inOff, inSize);
+			auto hash = ext.sha3(inOff, inSize);
+			stack.push(hash);
+		}
 
-			case Instruction::MSTORE:
-			{
-				auto addr = stack.pop();
-				auto word = stack.pop();
-				memory.storeWord(addr, word);
-				break;
-			}
+		case Instruction::POP:
+		{
+			stack.pop();
+			break;
+		}
 
-			case Instruction::MSTORE8:
+		case Instruction::ANY_PUSH:
+		{
+			auto numBytes = static_cast<size_t>(inst)-static_cast<size_t>(Instruction::PUSH1) + 1;
+			auto value = llvm::APInt(256, 0);
+			for (decltype(numBytes) i = 0; i < numBytes; ++i)	// TODO: Use pc as iterator
 			{
-				auto addr = stack.pop();
-				auto word = stack.pop();
-				memory.storeByte(addr, word);
-				break;
+				++currentPC;
+				value <<= 8;
+				value |= bytecode[currentPC];
 			}
+			auto c = m_builder.getInt(value);
+			stack.push(c);
+			break;
+		}
 
-			case Instruction::MSIZE:
-			{
-				auto word = memory.getSize();
-				stack.push(word);
-				break;
-			}
+		case Instruction::ANY_DUP:
+		{
+			auto index = static_cast<size_t>(inst)-static_cast<size_t>(Instruction::DUP1);
+			stack.dup(index);
+			break;
+		}
 
-			case Instruction::SLOAD:
-			{
-				auto index = stack.pop();
-				auto value = ext.store(index);
-				stack.push(value);
-				break;
-			}
+		case Instruction::ANY_SWAP:
+		{
+			auto index = static_cast<size_t>(inst)-static_cast<size_t>(Instruction::SWAP1) + 1;
+			stack.swap(index);
+			break;
+		}
 
-			case Instruction::SSTORE:
-			{
-				auto index = stack.pop();
-				auto value = stack.pop();
-				gasMeter.countSStore(ext, index, value);
-				ext.setStore(index, value);
-				break;
-			}
+		case Instruction::MLOAD:
+		{
+			auto addr = stack.pop();
+			auto word = memory.loadWord(addr);
+			stack.push(word);
+			break;
+		}
 
-			case Instruction::JUMP:
-			case Instruction::JUMPI:
-			{
-				// Generate direct jump iff:
-				// 1. this is not the first instruction in the block
-				// 2. m_directJumpTargets[currentPC] is defined (meaning that the previous instruction is a PUSH)
-				// Otherwise generate a indirect jump (a switch).
-				BasicBlock* targetBlock = nullptr;
-				if (currentPC != basicBlock.begin())
-				{
-					auto pairIter = m_directJumpTargets.find(currentPC);
-					if (pairIter != m_directJumpTargets.end())
-					{
-						targetBlock = pairIter->second;
-					}
-				}
+		case Instruction::MSTORE:
+		{
+			auto addr = stack.pop();
+			auto word = stack.pop();
+			memory.storeWord(addr, word);
+			break;
+		}
 
-				if (inst == Instruction::JUMP)
-				{
-					if (targetBlock)
-					{
-						// The target address is computed at compile time,
-						// just pop it without looking...
-						stack.pop();
-						m_builder.CreateBr(targetBlock->llvm());
-					}
-					else
-					{
-						// FIXME: this get(0) is a temporary workaround to get some of the jump tests running.
-						stack.get(0);
-						m_builder.CreateBr(m_jumpTableBlock->llvm());
-					}
-				}
-				else // JUMPI
-				{
-					stack.swap(1);
-					auto val = stack.pop();
-					auto zero = Constant::get(0);
-					auto cond = m_builder.CreateICmpNE(val, zero, "nonzero");
-
-					// Assume the basic blocks are properly ordered:
-					auto nextBBIter = basicBlockPairIt;
-					++nextBBIter;
-					assert (nextBBIter != basicBlocks.end());
-					auto& followBlock = nextBBIter->second;
-
-					if (targetBlock)
-					{
-						stack.pop();
-						m_builder.CreateCondBr(cond, targetBlock->llvm(), followBlock.llvm());
-					}
-					else
-					{
-						m_builder.CreateCondBr(cond, m_jumpTableBlock->llvm(), followBlock.llvm());
-					}
-				}
+		case Instruction::MSTORE8:
+		{
+			auto addr = stack.pop();
+			auto word = stack.pop();
+			memory.storeByte(addr, word);
+			break;
+		}
 
-				break;
-			}
+		case Instruction::MSIZE:
+		{
+			auto word = memory.getSize();
+			stack.push(word);
+			break;
+		}
 
-			case Instruction::JUMPDEST:
-			{
-				// Extra asserts just in case.
-				assert(currentPC == basicBlock.begin());
-				break;
-			}
+		case Instruction::SLOAD:
+		{
+			auto index = stack.pop();
+			auto value = ext.store(index);
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::PC:
-			{
-				auto value = Constant::get(currentPC);
-				stack.push(value);
-				break;
-			}
+		case Instruction::SSTORE:
+		{
+			auto index = stack.pop();
+			auto value = stack.pop();
+			gasMeter.countSStore(ext, index, value);
+			ext.setStore(index, value);
+			break;
+		}
 
-			case Instruction::GAS:
-			{
-				stack.push(gasMeter.getGas());
-				break;
+		case Instruction::JUMP:
+		case Instruction::JUMPI:
+		{
+			// Generate direct jump iff:
+			// 1. this is not the first instruction in the block
+			// 2. m_directJumpTargets[currentPC] is defined (meaning that the previous instruction is a PUSH)
+			// Otherwise generate a indirect jump (a switch).
+			BasicBlock* targetBlock = nullptr;
+			if (currentPC != basicBlock.begin())
+			{
+				auto pairIter = m_directJumpTargets.find(currentPC);
+				if (pairIter != m_directJumpTargets.end())
+				{
+					targetBlock = pairIter->second;
+				}
 			}
 
-			case Instruction::ADDRESS:
+			if (inst == Instruction::JUMP)
 			{
-				auto value = ext.address();
-				stack.push(value);
-				break;
+				if (targetBlock)
+				{
+					// The target address is computed at compile time,
+					// just pop it without looking...
+					stack.pop();
+					m_builder.CreateBr(targetBlock->llvm());
+				}
+				else
+				{
+					// FIXME: this get(0) is a temporary workaround to get some of the jump tests running.
+					stack.get(0);
+					m_builder.CreateBr(m_jumpTableBlock->llvm());
+				}
 			}
-
-			case Instruction::BALANCE:
+			else // JUMPI
 			{
-				auto address = stack.pop();
-				auto value = ext.balance(address);
-				stack.push(value);
-				break;
-			}
+				stack.swap(1);
+				auto val = stack.pop();
+				auto zero = Constant::get(0);
+				auto cond = m_builder.CreateICmpNE(val, zero, "nonzero");
 
-			case Instruction::CALLER:
-			{
-				auto value = ext.caller();
-				stack.push(value);
-				break;
-			}
+				// Assume the basic blocks are properly ordered:
+				assert(nextBasicBlock); // FIXME: JUMPI can be last instruction
 
-			case Instruction::ORIGIN:
-			{
-				auto value = ext.origin();
-				stack.push(value);
-				break;
+				if (targetBlock)
+				{
+					stack.pop();
+					m_builder.CreateCondBr(cond, targetBlock->llvm(), nextBasicBlock);
+				}
+				else
+				{
+					m_builder.CreateCondBr(cond, m_jumpTableBlock->llvm(), nextBasicBlock);
+				}
 			}
 
-			case Instruction::CALLVALUE:
-			{
-				auto value = ext.callvalue();
-				stack.push(value);
-				break;
-			}
+			break;
+		}
 
-			case Instruction::CALLDATASIZE:
-			{
-				auto value = ext.calldatasize();
-				stack.push(value);
-				break;
-			}
+		case Instruction::JUMPDEST:
+		{
+			// Extra asserts just in case.
+			assert(currentPC == basicBlock.begin());
+			break;
+		}
 
-			case Instruction::CODESIZE:
-			{
-				auto value = ext.codesize();
-				stack.push(value);
-				break;
-			}
+		case Instruction::PC:
+		{
+			auto value = Constant::get(currentPC);
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::EXTCODESIZE:
-			{
-				auto addr = stack.pop();
-				auto value = ext.codesizeAt(addr);
-				stack.push(value);
-				break;
-			}
+		case Instruction::GAS:
+		{
+			stack.push(gasMeter.getGas());
+			break;
+		}
 
-			case Instruction::CALLDATACOPY:
-			{
-				auto destMemIdx = stack.pop();
-				auto srcIdx = stack.pop();
-				auto reqBytes = stack.pop();
+		case Instruction::ADDRESS:
+		{
+			auto value = ext.address();
+			stack.push(value);
+			break;
+		}
 
-				auto srcPtr = ext.calldata();
-				auto srcSize = ext.calldatasize();
+		case Instruction::BALANCE:
+		{
+			auto address = stack.pop();
+			auto value = ext.balance(address);
+			stack.push(value);
+			break;
+		}
 
-				memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
-				break;
-			}
+		case Instruction::CALLER:
+		{
+			auto value = ext.caller();
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::CODECOPY:
-			{
-				auto destMemIdx = stack.pop();
-				auto srcIdx = stack.pop();
-				auto reqBytes = stack.pop();
+		case Instruction::ORIGIN:
+		{
+			auto value = ext.origin();
+			stack.push(value);
+			break;
+		}
 
-				auto srcPtr = ext.code();
-				auto srcSize = ext.codesize();
+		case Instruction::CALLVALUE:
+		{
+			auto value = ext.callvalue();
+			stack.push(value);
+			break;
+		}
 
-				memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
-				break;
-			}
+		case Instruction::CALLDATASIZE:
+		{
+			auto value = ext.calldatasize();
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::EXTCODECOPY:
-			{
-				auto extAddr = stack.pop();
-				auto destMemIdx = stack.pop();
-				auto srcIdx = stack.pop();
-				auto reqBytes = stack.pop();
+		case Instruction::CODESIZE:
+		{
+			auto value = ext.codesize();
+			stack.push(value);
+			break;
+		}
 
-				auto srcPtr = ext.codeAt(extAddr);
-				auto srcSize = ext.codesizeAt(extAddr);
+		case Instruction::EXTCODESIZE:
+		{
+			auto addr = stack.pop();
+			auto value = ext.codesizeAt(addr);
+			stack.push(value);
+			break;
+		}
 
-				memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
-				break;
-			}
+		case Instruction::CALLDATACOPY:
+		{
+			auto destMemIdx = stack.pop();
+			auto srcIdx = stack.pop();
+			auto reqBytes = stack.pop();
 
-			case Instruction::CALLDATALOAD:
-			{
-				auto index = stack.pop();
-				auto value = ext.calldataload(index);
-				stack.push(value);
-				break;
-			}
+			auto srcPtr = ext.calldata();
+			auto srcSize = ext.calldatasize();
 
-			case Instruction::GASPRICE:
-			{
-				auto value = ext.gasprice();
-				stack.push(value);
-				break;
-			}
+			memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
+			break;
+		}
 
-			case Instruction::PREVHASH:
-			{
-				auto value = ext.prevhash();
-				stack.push(value);
-				break;
-			}
+		case Instruction::CODECOPY:
+		{
+			auto destMemIdx = stack.pop();
+			auto srcIdx = stack.pop();
+			auto reqBytes = stack.pop();
 
-			case Instruction::COINBASE:
-			{
-				auto value = ext.coinbase();
-				stack.push(value);
-				break;
-			}
+			auto srcPtr = ext.code();
+			auto srcSize = ext.codesize();
 
-			case Instruction::TIMESTAMP:
-			{
-				auto value = ext.timestamp();
-				stack.push(value);
-				break;
-			}
+			memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
+			break;
+		}
 
-			case Instruction::NUMBER:
-			{
-				auto value = ext.number();
-				stack.push(value);
-				break;
-			}
+		case Instruction::EXTCODECOPY:
+		{
+			auto extAddr = stack.pop();
+			auto destMemIdx = stack.pop();
+			auto srcIdx = stack.pop();
+			auto reqBytes = stack.pop();
 
-			case Instruction::DIFFICULTY:
-			{
-				auto value = ext.difficulty();
-				stack.push(value);
-				break;
-			}
+			auto srcPtr = ext.codeAt(extAddr);
+			auto srcSize = ext.codesizeAt(extAddr);
 
-			case Instruction::GASLIMIT:
-			{
-				auto value = ext.gaslimit();
-				stack.push(value);
-				break;
-			}
+			memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
+			break;
+		}
 
-			case Instruction::CREATE:
-			{
-				auto endowment = stack.pop();
-				auto initOff = stack.pop();
-				auto initSize = stack.pop();
-				memory.require(initOff, initSize);
+		case Instruction::CALLDATALOAD:
+		{
+			auto index = stack.pop();
+			auto value = ext.calldataload(index);
+			stack.push(value);
+			break;
+		}
 
-				auto address = ext.create(endowment, initOff, initSize);
-				stack.push(address);
-				break;
-			}
+		case Instruction::GASPRICE:
+		{
+			auto value = ext.gasprice();
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::CALL:
-			case Instruction::CALLCODE:
-			{
-				auto gas = stack.pop();
-				auto codeAddress = stack.pop();
-				auto value = stack.pop();
-				auto inOff = stack.pop();
-				auto inSize = stack.pop();
-				auto outOff = stack.pop();
-				auto outSize = stack.pop();
-
-				gasMeter.commitCostBlock(gas);
-
-				// Require memory for the max of in and out buffers
-				auto inSizeReq = m_builder.CreateAdd(inOff, inSize, "inSizeReq");
-				auto outSizeReq = m_builder.CreateAdd(outOff, outSize, "outSizeReq");
-				auto cmp = m_builder.CreateICmpUGT(inSizeReq, outSizeReq);
-				auto sizeReq = m_builder.CreateSelect(cmp, inSizeReq, outSizeReq, "sizeReq");
-				memory.require(sizeReq);
-
-				auto receiveAddress = codeAddress;
-				if (inst == Instruction::CALLCODE)
-					receiveAddress = ext.address();
-
-				auto ret = ext.call(gas, receiveAddress, value, inOff, inSize, outOff, outSize, codeAddress);
-				gasMeter.giveBack(gas);
-				stack.push(ret);
-				break;
-			}
+		case Instruction::PREVHASH:
+		{
+			auto value = ext.prevhash();
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::RETURN:
-			{
-				auto index = stack.pop();
-				auto size = stack.pop();
+		case Instruction::COINBASE:
+		{
+			auto value = ext.coinbase();
+			stack.push(value);
+			break;
+		}
 
-				memory.registerReturnData(index, size);
+		case Instruction::TIMESTAMP:
+		{
+			auto value = ext.timestamp();
+			stack.push(value);
+			break;
+		}
 
-				m_builder.CreateRet(Constant::get(ReturnCode::Return));
-				break;
-			}
+		case Instruction::NUMBER:
+		{
+			auto value = ext.number();
+			stack.push(value);
+			break;
+		}
 
-			case Instruction::SUICIDE:
-			{
-				auto address = stack.pop();
-				ext.suicide(address);
-				// Fall through
-			}
-			case Instruction::STOP:
-			{
-				m_builder.CreateRet(Constant::get(ReturnCode::Stop));
-				break;
-			}
+		case Instruction::DIFFICULTY:
+		{
+			auto value = ext.difficulty();
+			stack.push(value);
+			break;
+		}
 
-			}
+		case Instruction::GASLIMIT:
+		{
+			auto value = ext.gaslimit();
+			stack.push(value);
+			break;
 		}
 
-		gasMeter.commitCostBlock();
+		case Instruction::CREATE:
+		{
+			auto endowment = stack.pop();
+			auto initOff = stack.pop();
+			auto initSize = stack.pop();
+			memory.require(initOff, initSize);
+
+			auto address = ext.create(endowment, initOff, initSize);
+			stack.push(address);
+			break;
+		}
 
-		if (!m_builder.GetInsertBlock()->getTerminator())	// If block not terminated
+		case Instruction::CALL:
+		case Instruction::CALLCODE:
 		{
-			if (basicBlock.end() == bytecode.size())
-			{
-				// Return STOP code
-				m_builder.CreateRet(Constant::get(ReturnCode::Stop));
-			}
-			else
-			{
-				// Branch to the next block.
-				auto iterCopy = basicBlockPairIt;
-				++iterCopy;
-				auto& next = iterCopy->second;
-				m_builder.CreateBr(next);
-			}
+			auto gas = stack.pop();
+			auto codeAddress = stack.pop();
+			auto value = stack.pop();
+			auto inOff = stack.pop();
+			auto inSize = stack.pop();
+			auto outOff = stack.pop();
+			auto outSize = stack.pop();
+
+			gasMeter.commitCostBlock(gas);
+
+			// Require memory for the max of in and out buffers
+			auto inSizeReq = m_builder.CreateAdd(inOff, inSize, "inSizeReq");
+			auto outSizeReq = m_builder.CreateAdd(outOff, outSize, "outSizeReq");
+			auto cmp = m_builder.CreateICmpUGT(inSizeReq, outSizeReq);
+			auto sizeReq = m_builder.CreateSelect(cmp, inSizeReq, outSizeReq, "sizeReq");
+			memory.require(sizeReq);
+
+			auto receiveAddress = codeAddress;
+			if (inst == Instruction::CALLCODE)
+				receiveAddress = ext.address();
+
+			auto ret = ext.call(gas, receiveAddress, value, inOff, inSize, outOff, outSize, codeAddress);
+			gasMeter.giveBack(gas);
+			stack.push(ret);
+			break;
 		}
-	}
 
-	// Code for special blocks:
-	// TODO: move to separate function.
-	// Note: Right now the codegen for special blocks depends only on createBasicBlock(),
-	// not on the codegen for 'regular' blocks. But it has to be done before linkBasicBlocks().
-	m_builder.SetInsertPoint(m_stopBB);
-	m_builder.CreateRet(Constant::get(ReturnCode::Stop));
+		case Instruction::RETURN:
+		{
+			auto index = stack.pop();
+			auto size = stack.pop();
 
-	m_builder.SetInsertPoint(m_badJumpBlock->llvm());
-	m_builder.CreateRet(Constant::get(ReturnCode::BadJumpDestination));
+			memory.registerReturnData(index, size);
 
-	m_builder.SetInsertPoint(m_jumpTableBlock->llvm());
-	if (m_indirectJumpTargets.size() > 0)
-	{
-		auto& stack = m_jumpTableBlock->getStack();
+			m_builder.CreateRet(Constant::get(ReturnCode::Return));
+			break;
+		}
 
-		auto dest = stack.pop();
-		auto switchInstr = 	m_builder.CreateSwitch(dest, m_badJumpBlock->llvm(),
-		                   	                     m_indirectJumpTargets.size());
-		for (auto it = m_indirectJumpTargets.cbegin(); it != m_indirectJumpTargets.cend(); ++it)
+		case Instruction::SUICIDE:
 		{
-			auto& bb = *it;
-			auto dest = Constant::get(bb->begin());
-			switchInstr->addCase(dest, bb->llvm());
+			auto address = stack.pop();
+			ext.suicide(address);
+			// Fall through
+		}
+		case Instruction::STOP:
+		{
+			m_builder.CreateRet(Constant::get(ReturnCode::Stop));
+			break;
+		}
+
 		}
-	}
-	else
-	{
-		m_builder.CreateBr(m_badJumpBlock->llvm());
 	}
 
-	linkBasicBlocks();
+	gasMeter.commitCostBlock();
 
-	return module;
+	if (!m_builder.GetInsertBlock()->getTerminator())	// If block not terminated
+	{
+		if (basicBlock.end() == bytecode.size())
+		{
+			// Return STOP code
+			m_builder.CreateRet(Constant::get(ReturnCode::Stop));
+		}
+		else
+		{
+			// Branch to the next block.
+			assert(nextBasicBlock);
+			m_builder.CreateBr(nextBasicBlock);
+		}
+	}
 }
 
 
diff --git a/evmcc/Compiler.h b/evmcc/Compiler.h
index 1aa54fa18..1a0e61ca1 100644
--- a/evmcc/Compiler.h
+++ b/evmcc/Compiler.h
@@ -28,6 +28,8 @@ private:
 
 	void createBasicBlocks(const bytes& bytecode);
 
+	void compileBasicBlock(BasicBlock& basicBlock, const bytes& bytecode, class Memory& memory, class Ext& ext, class GasMeter& gasMeter, llvm::BasicBlock* nextBasicBlock);
+
 	void linkBasicBlocks();
 
 	llvm::IRBuilder<> m_builder;