path: root/libsolidity/codegen/ContractCompiler.cpp

/*
    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/>.
*/
/**
 * @author Christian <c@ethdev.com>
 * @date 2014
 * Solidity compiler.
 */

#include <libsolidity/codegen/ContractCompiler.h>
#include <libsolidity/inlineasm/AsmCodeGen.h>
#include <libsolidity/ast/AST.h>
#include <libsolidity/interface/ErrorReporter.h>
#include <libsolidity/codegen/ExpressionCompiler.h>
#include <libsolidity/codegen/CompilerUtils.h>

#include <libevmasm/Instruction.h>
#include <libevmasm/Assembly.h>
#include <libevmasm/GasMeter.h>

#include <boost/range/adaptor/reversed.hpp>

#include <algorithm>

using namespace std;
using namespace dev;
using namespace dev::solidity;

namespace
{

/**
 * Simple helper class to ensure that the stack height is the same at certain places in the code.
 */
class StackHeightChecker
{
public:
    explicit StackHeightChecker(CompilerContext const& _context):
        m_context(_context), stackHeight(m_context.stackHeight()) {}
    void check() { solAssert(m_context.stackHeight() == stackHeight, std::string("I sense a disturbance in the stack: ") + to_string(m_context.stackHeight()) + " vs " + to_string(stackHeight)); }
private:
    CompilerContext const& m_context;
    unsigned stackHeight;
};

}

void ContractCompiler::compileContract(
    ContractDefinition const& _contract,
    std::map<const ContractDefinition*, eth::Assembly const*> const& _contracts
)
{
    CompilerContext::LocationSetter locationSetter(m_context, _contract);

    if (_contract.isLibrary())
        // Check whether this is a call (true) or a delegatecall (false).
        // This has to be the first code in the contract.
        appendDelegatecallCheck();

    initializeContext(_contract, _contracts);
    // This generates the dispatch function for externally visible functions
    // and adds the function to the compilation queue. Additionally internal functions,
    // which are referenced directly or indirectly will be added.
    appendFunctionSelector(_contract);
    // This processes the above populated queue until it is empty.
    appendMissingFunctions();
}

size_t ContractCompiler::compileConstructor(
    ContractDefinition const& _contract,
    std::map<const ContractDefinition*, eth::Assembly const*> const& _contracts
)
{
    CompilerContext::LocationSetter locationSetter(m_context, _contract);
    if (_contract.isLibrary())
        return deployLibrary(_contract);
    else
    {
        initializeContext(_contract, _contracts);
        return packIntoContractCreator(_contract);
    }
}

void ContractCompiler::initializeContext(
    ContractDefinition const& _contract,
    map<ContractDefinition const*, eth::Assembly const*> const& _compiledContracts
)
{
    m_context.setExperimentalFeatures(_contract.sourceUnit().annotation().experimentalFeatures);
    m_context.setCompiledContracts(_compiledContracts);
    m_context.setInheritanceHierarchy(_contract.annotation().linearizedBaseContracts);
    CompilerUtils(m_context).initialiseFreeMemoryPointer();
    registerStateVariables(_contract);
    m_context.resetVisitedNodes(&_contract);
}

void ContractCompiler::appendCallValueCheck()
{
    // Throw if function is not payable but call contained ether.
    m_context << Instruction::CALLVALUE;
    // TODO: error message?
    m_context.appendConditionalRevert();
}

void ContractCompiler::appendInitAndConstructorCode(ContractDefinition const& _contract)
{
    solAssert(!_contract.isLibrary(), "Tried to initialize library.");
    CompilerContext::LocationSetter locationSetter(m_context, _contract);

    m_baseArguments = &_contract.annotation().baseConstructorArguments;

    // Initialization of state variables in base-to-derived order.
    for (ContractDefinition const* contract: boost::adaptors::reverse(
        _contract.annotation().linearizedBaseContracts
    ))
        initializeStateVariables(*contract);

    if (FunctionDefinition const* constructor = _contract.constructor())
        appendConstructor(*constructor);
    else if (auto c = m_context.nextConstructor(_contract))
        appendBaseConstructor(*c);
    else
        appendCallValueCheck();
}

size_t ContractCompiler::packIntoContractCreator(ContractDefinition const& _contract)
{
    solAssert(!!m_runtimeCompiler, "");
    solAssert(!_contract.isLibrary(), "Tried to use contract creator or library.");

    appendInitAndConstructorCode(_contract);

    // We jump to the deploy routine because we first have to append all missing functions,
    // which can cause further functions to be added to the runtime context.
    eth::AssemblyItem deployRoutine = m_context.appendJumpToNew();

    // We have to include copies of functions in the construction time and runtime context
    // because of absolute jumps.
    appendMissingFunctions();
    m_runtimeCompiler->appendMissingFunctions();

    CompilerContext::LocationSetter locationSetter(m_context, _contract);
    m_context << deployRoutine;

    solAssert(m_context.runtimeSub() != size_t(-1), "Runtime sub not registered");
    m_context.pushSubroutineSize(m_context.runtimeSub());
    m_context << Instruction::DUP1;
    m_context.pushSubroutineOffset(m_context.runtimeSub());
    m_context << u256(0) << Instruction::CODECOPY;
    m_context << u256(0) << Instruction::RETURN;

    return m_context.runtimeSub();
}

size_t ContractCompiler::deployLibrary(ContractDefinition const& _contract)
{
    solAssert(!!m_runtimeCompiler, "");
    solAssert(_contract.isLibrary(), "Tried to deploy contract as library.");

    CompilerContext::LocationSetter locationSetter(m_context, _contract);

    solAssert(m_context.runtimeSub() != size_t(-1), "Runtime sub not registered");
    m_context.pushSubroutineSize(m_context.runtimeSub());
    m_context.pushSubroutineOffset(m_context.runtimeSub());
    m_context.appendInlineAssembly(R"(
    {
        // If code starts at 11, an mstore(0) writes to the full PUSH20 plus data
        // without the need for a shift.
        let codepos := 11
        codecopy(codepos, subOffset, subSize)
        // Check that the first opcode is a PUSH20
        switch eq(0x73, byte(0, mload(codepos)))
        case 0 { invalid() }
        mstore(0, address())
        mstore8(codepos, 0x73)
        return(codepos, subSize)
    }
    )", {"subSize", "subOffset"});

    return m_context.runtimeSub();
}

void ContractCompiler::appendBaseConstructor(FunctionDefinition const& _constructor)
{
    CompilerContext::LocationSetter locationSetter(m_context, _constructor);
    FunctionType constructorType(_constructor);
    if (!constructorType.parameterTypes().empty())
    {
        solAssert(m_baseArguments, "");
        solAssert(m_baseArguments->count(&_constructor), "");
        std::vector<ASTPointer<Expression>> const* arguments = nullptr;
        ASTNode const* baseArgumentNode = m_baseArguments->at(&_constructor);
        if (auto inheritanceSpecifier = dynamic_cast<InheritanceSpecifier const*>(baseArgumentNode))
            arguments = inheritanceSpecifier->arguments();
        else if (auto modifierInvocation = dynamic_cast<ModifierInvocation const*>(baseArgumentNode))
            arguments = modifierInvocation->arguments();
        solAssert(arguments, "");
        solAssert(arguments->size() == constructorType.parameterTypes().size(), "");
        for (unsigned i = 0; i < arguments->size(); ++i)
            compileExpression(*(arguments->at(i)), constructorType.parameterTypes()[i]);
    }
    _constructor.accept(*this);
}

void ContractCompiler::appendConstructor(FunctionDefinition const& _constructor)
{
    CompilerContext::LocationSetter locationSetter(m_context, _constructor);
    if (!_constructor.isPayable())
        appendCallValueCheck();

    // copy constructor arguments from code to memory and then to stack, they are supplied after the actual program
    if (!_constructor.parameters().empty())
    {
        unsigned argumentSize = 0;
        for (ASTPointer<VariableDeclaration> const& var: _constructor.parameters())
            if (var->annotation().type->isDynamicallySized())
            {
                argumentSize = 0;
                break;
            }
            else
                argumentSize += var->annotation().type->calldataEncodedSize();

        CompilerUtils(m_context).fetchFreeMemoryPointer();
        if (argumentSize == 0)
        {
            // argument size is dynamic, use CODESIZE to determine it
            m_context.appendProgramSize(); // program itself
            // CODESIZE is program plus manually added arguments
            m_context << Instruction::CODESIZE << Instruction::SUB;
        }
        else
            m_context << u256(argumentSize);
        // stack: <memptr> <argument size>
        m_context << Instruction::DUP1;
        m_context.appendProgramSize();
        m_context << Instruction::DUP4 << Instruction::CODECOPY;
        m_context << Instruction::DUP2 << Instruction::ADD;
        m_context << Instruction::DUP1;
        CompilerUtils(m_context).storeFreeMemoryPointer();
        // stack: <memptr>
        CompilerUtils(m_context).abiDecode(FunctionType(_constructor).parameterTypes(), true);
    }
    _constructor.accept(*this);
}

void ContractCompiler::appendDelegatecallCheck()
{
    // Special constant that will be replaced by the address at deploy time.
    // At compilation time, this is just "PUSH20 00...000".
    m_context.appendDeployTimeAddress();
    m_context << Instruction::ADDRESS << Instruction::EQ;
    // The result on the stack is
    // "We have not been called via DELEGATECALL".
}

void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contract)
{
    map<FixedHash<4>, FunctionTypePointer> interfaceFunctions = _contract.interfaceFunctions();
    map<FixedHash<4>, const eth::AssemblyItem> callDataUnpackerEntryPoints;

    if (_contract.isLibrary())
    {
        solAssert(m_context.stackHeight() == 1, "CALL / DELEGATECALL flag expected.");
    }

    FunctionDefinition const* fallback = _contract.fallbackFunction();
    eth::AssemblyItem notFound = m_context.newTag();
    // directly jump to fallback if the data is too short to contain a function selector
    // also guards against short data
    m_context << u256(4) << Instruction::CALLDATASIZE << Instruction::LT;
    m_context.appendConditionalJumpTo(notFound);

    // retrieve the function signature hash from the calldata
    if (!interfaceFunctions.empty())
        CompilerUtils(m_context).loadFromMemory(0, IntegerType(CompilerUtils::dataStartOffset * 8), true);

    // stack now is: <can-call-non-view-functions>? <funhash>
    for (auto const& it: interfaceFunctions)
    {
        callDataUnpackerEntryPoints.insert(std::make_pair(it.first, m_context.newTag()));
        m_context << dupInstruction(1) << u256(FixedHash<4>::Arith(it.first)) << Instruction::EQ;
        m_context.appendConditionalJumpTo(callDataUnpackerEntryPoints.at(it.first));
    }
    m_context.appendJumpTo(notFound);

    m_context << notFound;
    if (fallback)
    {
        solAssert(!_contract.isLibrary(), "");
        if (!fallback->isPayable())
            appendCallValueCheck();

        solAssert(fallback->isFallback(), "");
        solAssert(FunctionType(*fallback).parameterTypes().empty(), "");
        solAssert(FunctionType(*fallback).returnParameterTypes().empty(), "");
        fallback->accept(*this);
        m_context << Instruction::STOP;
    }
    else
        // TODO: error message here?
        m_context.appendRevert();

    for (auto const& it: interfaceFunctions)
    {
        FunctionTypePointer const& functionType = it.second;
        solAssert(functionType->hasDeclaration(), "");
        CompilerContext::LocationSetter locationSetter(m_context, functionType->declaration());

        m_context << callDataUnpackerEntryPoints.at(it.first);
        if (_contract.isLibrary() && functionType->stateMutability() > StateMutability::View)
        {
            // If the function is not a view function and is called without DELEGATECALL,
            // we revert.
            m_context << dupInstruction(2);
            m_context.appendConditionalRevert();
        }
        m_context.setStackOffset(0);
        // We have to allow this for libraries, because value of the previous
        // call is still visible in the delegatecall.
        if (!functionType->isPayable() && !_contract.isLibrary())
            appendCallValueCheck();

        // Return tag is used to jump out of the function.
        eth::AssemblyItem returnTag = m_context.pushNewTag();
        if (!functionType->parameterTypes().empty())
        {
            // Parameter for calldataUnpacker
            m_context << CompilerUtils::dataStartOffset;
            m_context << Instruction::DUP1 << Instruction::CALLDATASIZE << Instruction::SUB;
            CompilerUtils(m_context).abiDecode(functionType->parameterTypes());
        }
        m_context.appendJumpTo(m_context.functionEntryLabel(functionType->declaration()));
        m_context << returnTag;
        // Return tag and input parameters get consumed.
        m_context.adjustStackOffset(
            CompilerUtils(m_context).sizeOnStack(functionType->returnParameterTypes()) -
            CompilerUtils(m_context).sizeOnStack(functionType->parameterTypes()) -
            1
        );
        // Consumes the return parameters.
        appendReturnValuePacker(functionType->returnParameterTypes(), _contract.isLibrary());
    }
}

void ContractCompiler::appendReturnValuePacker(TypePointers const& _typeParameters, bool _isLibrary)
{
    CompilerUtils utils(m_context);
    if (_typeParameters.empty())
        m_context << Instruction::STOP;
    else
    {
        utils.fetchFreeMemoryPointer();
        //@todo optimization: if we return a single memory array, there should be enough space before
        // its data to add the needed parts and we avoid a memory copy.
        utils.abiEncode(_typeParameters, _typeParameters, _isLibrary);
        utils.toSizeAfterFreeMemoryPointer();
        m_context << Instruction::RETURN;
    }
}

void ContractCompiler::registerStateVariables(ContractDefinition const& _contract)
{
    for (auto const& var: ContractType(_contract).stateVariables())
        m_context.addStateVariable(*get<0>(var), get<1>(var), get<2>(var));
}

void ContractCompiler::initializeStateVariables(ContractDefinition const& _contract)
{
    solAssert(!_contract.isLibrary(), "Tried to initialize state variables of library.");
    for (VariableDeclaration const* variable: _contract.stateVariables())
        if (variable->value() && !variable->isConstant())
            ExpressionCompiler(m_context, m_optimise).appendStateVariableInitialization(*variable);
}

bool ContractCompiler::visit(VariableDeclaration const& _variableDeclaration)
{
    solAssert(_variableDeclaration.isStateVariable(), "Compiler visit to non-state variable declaration.");
    CompilerContext::LocationSetter locationSetter(m_context, _variableDeclaration);

    m_context.startFunction(_variableDeclaration);
    m_breakTags.clear();
    m_continueTags.clear();

    if (_variableDeclaration.isConstant())
        ExpressionCompiler(m_context, m_optimise).appendConstStateVariableAccessor(_variableDeclaration);
    else
        ExpressionCompiler(m_context, m_optimise).appendStateVariableAccessor(_variableDeclaration);

    return false;
}

bool ContractCompiler::visit(FunctionDefinition const& _function)
{
    CompilerContext::LocationSetter locationSetter(m_context, _function);

    m_context.startFunction(_function);

    // stack upon entry: [return address] [arg0] [arg1] ... [argn]
    // reserve additional slots: [retarg0] ... [retargm]

    unsigned parametersSize = CompilerUtils::sizeOnStack(_function.parameters());
    if (!_function.isConstructor())
        // adding 1 for return address.
        m_context.adjustStackOffset(parametersSize + 1);
    for (ASTPointer<VariableDeclaration const> const& variable: _function.parameters())
    {
        m_context.addVariable(*variable, parametersSize);
        parametersSize -= variable->annotation().type->sizeOnStack();
    }

    for (ASTPointer<VariableDeclaration const> const& variable: _function.returnParameters())
        appendStackVariableInitialisation(*variable);

    if (_function.isConstructor())
        if (auto c = m_context.nextConstructor(dynamic_cast<ContractDefinition const&>(*_function.scope())))
            appendBaseConstructor(*c);

    solAssert(m_returnTags.empty(), "");
    m_breakTags.clear();
    m_continueTags.clear();
    m_currentFunction = &_function;
    m_modifierDepth = -1;
    m_scopeStackHeight.clear();

    appendModifierOrFunctionCode();
    solAssert(m_returnTags.empty(), "");

    // Now we need to re-shuffle the stack. For this we keep a record of the stack layout
    // that shows the target positions of the elements, where "-1" denotes that this element needs
    // to be removed from the stack.
    // Note that the fact that the return arguments are of increasing index is vital for this
    // algorithm to work.

    unsigned const c_argumentsSize = CompilerUtils::sizeOnStack(_function.parameters());
    unsigned const c_returnValuesSize = CompilerUtils::sizeOnStack(_function.returnParameters());

    vector<int> stackLayout;
    stackLayout.push_back(c_returnValuesSize); // target of return address
    stackLayout += vector<int>(c_argumentsSize, -1); // discard all arguments
    for (unsigned i = 0; i < c_returnValuesSize; ++i)
        stackLayout.push_back(i);

    if (stackLayout.size() > 17)
        BOOST_THROW_EXCEPTION(
            CompilerError() <<
            errinfo_sourceLocation(_function.location()) <<
            errinfo_comment("Stack too deep, try removing local variables.")
        );
    while (stackLayout.back() != int(stackLayout.size() - 1))
        if (stackLayout.back() < 0)
        {
            m_context << Instruction::POP;
            stackLayout.pop_back();
        }
        else
        {
            m_context << swapInstruction(stackLayout.size() - stackLayout.back() - 1);
            swap(stackLayout[stackLayout.back()], stackLayout.back());
        }
    for (int i = 0; i < int(stackLayout.size()); ++i)
        if (stackLayout[i] != i)
            solAssert(false, "Invalid stack layout on cleanup.");

    for (ASTPointer<VariableDeclaration const> const& variable: _function.parameters() + _function.returnParameters())
        m_context.removeVariable(*variable);

    m_context.adjustStackOffset(-(int)c_returnValuesSize);

    /// The constructor and the fallback function doesn't to jump out.
    if (!_function.isConstructor())
    {
        solAssert(m_context.numberOfLocalVariables() == 0, "");
        if (!_function.isFallback())
            m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction);
    }

    return false;
}

bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
{
    unsigned startStackHeight = m_context.stackHeight();
    julia::ExternalIdentifierAccess identifierAccess;
    identifierAccess.resolve = [&](assembly::Identifier const& _identifier, julia::IdentifierContext, bool)
    {
        auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
        if (ref == _inlineAssembly.annotation().externalReferences.end())
            return size_t(-1);
        return ref->second.valueSize;
    };
    identifierAccess.generateCode = [&](assembly::Identifier const& _identifier, julia::IdentifierContext _context, julia::AbstractAssembly& _assembly)
    {
        auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
        solAssert(ref != _inlineAssembly.annotation().externalReferences.end(), "");
        Declaration const* decl = ref->second.declaration;
        solAssert(!!decl, "");
        if (_context == julia::IdentifierContext::RValue)
        {
            int const depositBefore = _assembly.stackHeight();
            solAssert(!!decl->type(), "Type of declaration required but not yet determined.");
            if (FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(decl))
            {
                solAssert(!ref->second.isOffset && !ref->second.isSlot, "");
                functionDef = &m_context.resolveVirtualFunction(*functionDef);
                auto functionEntryLabel = m_context.functionEntryLabel(*functionDef).pushTag();
                solAssert(functionEntryLabel.data() <= std::numeric_limits<size_t>::max(), "");
                _assembly.appendLabelReference(size_t(functionEntryLabel.data()));
                // If there is a runtime context, we have to merge both labels into the same
                // stack slot in case we store it in storage.
                if (CompilerContext* rtc = m_context.runtimeContext())
                {
                    _assembly.appendConstant(u256(1) << 32);
                    _assembly.appendInstruction(Instruction::MUL);
                    auto runtimeEntryLabel = rtc->functionEntryLabel(*functionDef).toSubAssemblyTag(m_context.runtimeSub());
                    solAssert(runtimeEntryLabel.data() <= std::numeric_limits<size_t>::max(), "");
                    _assembly.appendLabelReference(size_t(runtimeEntryLabel.data()));
                    _assembly.appendInstruction(Instruction::OR);
                }
            }
            else if (auto variable = dynamic_cast<VariableDeclaration const*>(decl))
            {
                solAssert(!variable->isConstant(), "");
                if (m_context.isStateVariable(decl))
                {
                    auto const& location = m_context.storageLocationOfVariable(*decl);
                    if (ref->second.isSlot)
                        m_context << location.first;
                    else if (ref->second.isOffset)
                        m_context << u256(location.second);
                    else
                        solAssert(false, "");
                }
                else if (m_context.isLocalVariable(decl))
                {
                    int stackDiff = _assembly.stackHeight() - m_context.baseStackOffsetOfVariable(*variable);
                    if (ref->second.isSlot || ref->second.isOffset)
                    {
                        solAssert(variable->type()->dataStoredIn(DataLocation::Storage), "");
                        unsigned size = variable->type()->sizeOnStack();
                        if (size == 2)
                        {
                            // slot plus offset
                            if (ref->second.isOffset)
                                stackDiff--;
                        }
                        else
                        {
                            solAssert(size == 1, "");
                            // only slot, offset is zero
                            if (ref->second.isOffset)
                            {
                                _assembly.appendConstant(u256(0));
                                return;
                            }
                        }
                    }
                    else
                        solAssert(variable->type()->sizeOnStack() == 1, "");
                    if (stackDiff < 1 || stackDiff > 16)
                        BOOST_THROW_EXCEPTION(
                            CompilerError() <<
                            errinfo_sourceLocation(_inlineAssembly.location()) <<
                            errinfo_comment("Stack too deep, try removing local variables.")
                        );
                    solAssert(variable->type()->sizeOnStack() == 1, "");
                    _assembly.appendInstruction(dupInstruction(stackDiff));
                }
                else
                    solAssert(false, "");
            }
            else if (auto contract = dynamic_cast<ContractDefinition const*>(decl))
            {
                solAssert(!ref->second.isOffset && !ref->second.isSlot, "");
                solAssert(contract->isLibrary(), "");
                _assembly.appendLinkerSymbol(contract->fullyQualifiedName());
            }
            else
                solAssert(false, "Invalid declaration type.");
            solAssert(_assembly.stackHeight() - depositBefore == int(ref->second.valueSize), "");
        }
        else
        {
            // lvalue context
            solAssert(!ref->second.isOffset && !ref->second.isSlot, "");
            auto variable = dynamic_cast<VariableDeclaration const*>(decl);
            solAssert(
                !!variable && m_context.isLocalVariable(variable),
                "Can only assign to stack variables in inline assembly."
            );
            solAssert(variable->type()->sizeOnStack() == 1, "");
            int stackDiff = _assembly.stackHeight() - m_context.baseStackOffsetOfVariable(*variable) - 1;
            if (stackDiff > 16 || stackDiff < 1)
                BOOST_THROW_EXCEPTION(
                    CompilerError() <<
                    errinfo_sourceLocation(_inlineAssembly.location()) <<
                    errinfo_comment("Stack too deep(" + to_string(stackDiff) + "), try removing local variables.")
                );
            _assembly.appendInstruction(swapInstruction(stackDiff));
            _assembly.appendInstruction(Instruction::POP);
        }
    };
    solAssert(_inlineAssembly.annotation().analysisInfo, "");
    assembly::CodeGenerator::assemble(
        _inlineAssembly.operations(),
        *_inlineAssembly.annotation().analysisInfo,
        m_context.nonConstAssembly(),
        identifierAccess
    );
    m_context.setStackOffset(startStackHeight);
    return false;
}

bool ContractCompiler::visit(IfStatement const& _ifStatement)
{
    StackHeightChecker checker(m_context);
    CompilerContext::LocationSetter locationSetter(m_context, _ifStatement);
    compileExpression(_ifStatement.condition());
    m_context << Instruction::ISZERO;
    eth::AssemblyItem falseTag = m_context.appendConditionalJump();
    eth::AssemblyItem endTag = falseTag;
    _ifStatement.trueStatement().accept(*this);
    if (_ifStatement.falseStatement())
    {
        endTag = m_context.appendJumpToNew();
        m_context << falseTag;
        _ifStatement.falseStatement()->accept(*this);
    }
    m_context << endTag;

    checker.check();
    return false;
}

bool ContractCompiler::visit(WhileStatement const& _whileStatement)
{
    StackHeightChecker checker(m_context);
    CompilerContext::LocationSetter locationSetter(m_context, _whileStatement);

    eth::AssemblyItem loopStart = m_context.newTag();
    eth::AssemblyItem loopEnd = m_context.newTag();
    m_breakTags.push_back({loopEnd, m_context.stackHeight()});

    m_context << loopStart;

    if (_whileStatement.isDoWhile())
    {
        eth::AssemblyItem condition = m_context.newTag();
        m_continueTags.push_back({condition, m_context.stackHeight()});

        _whileStatement.body().accept(*this);

        m_context << condition;
        compileExpression(_whileStatement.condition());
        m_context << Instruction::ISZERO << Instruction::ISZERO;
        m_context.appendConditionalJumpTo(loopStart);
    }
    else
    {
        m_continueTags.push_back({loopStart, m_context.stackHeight()});
        compileExpression(_whileStatement.condition());
        m_context << Instruction::ISZERO;
        m_context.appendConditionalJumpTo(loopEnd);

        _whileStatement.body().accept(*this);

        m_context.appendJumpTo(loopStart);
    }
    m_context << loopEnd;

    m_continueTags.pop_back();
    m_breakTags.pop_back();

    checker.check();
    return false;
}

bool ContractCompiler::visit(ForStatement const& _forStatement)
{
    StackHeightChecker checker(m_context);
    CompilerContext::LocationSetter locationSetter(m_context, _forStatement);
    eth::AssemblyItem loopStart = m_context.newTag();
    eth::AssemblyItem loopEnd = m_context.newTag();
    eth::AssemblyItem loopNext = m_context.newTag();

    storeStackHeight(&_forStatement);

    if (_forStatement.initializationExpression())
        _forStatement.initializationExpression()->accept(*this);

    m_breakTags.push_back({loopEnd, m_context.stackHeight()});
    m_continueTags.push_back({loopNext, m_context.stackHeight()});
    m_context << loopStart;

    // if there is no terminating condition in for, default is to always be true
    if (_forStatement.condition())
    {
        compileExpression(*_forStatement.condition());
        m_context << Instruction::ISZERO;
        m_context.appendConditionalJumpTo(loopEnd);
    }

    _forStatement.body().accept(*this);

    m_context << loopNext;

    // for's loop expression if existing
    if (_forStatement.loopExpression())
        _forStatement.loopExpression()->accept(*this);

    m_context.appendJumpTo(loopStart);

    m_context << loopEnd;

    m_continueTags.pop_back();
    m_breakTags.pop_back();

    // For the case where no break/return is executed:
    // loop initialization variables have to be freed
    popScopedVariables(&_forStatement);

    checker.check();
    return false;
}

bool ContractCompiler::visit(Continue const& _continueStatement)
{
    CompilerContext::LocationSetter locationSetter(m_context, _continueStatement);
    solAssert(!m_continueTags.empty(), "");
    CompilerUtils(m_context).popAndJump(m_continueTags.back().second, m_continueTags.back().first);
    return false;
}

bool ContractCompiler::visit(Break const& _breakStatement)
{
    CompilerContext::LocationSetter locationSetter(m_context, _breakStatement);
    solAssert(!m_breakTags.empty(), "");
    CompilerUtils(m_context).popAndJump(m_breakTags.back().second, m_breakTags.back().first);
    return false;
}

bool ContractCompiler::visit(Return const& _return)
{
    CompilerContext::LocationSetter locationSetter(m_context, _return);
    if (Expression const* expression = _return.expression())
    {
        solAssert(_return.annotation().functionReturnParameters, "Invalid return parameters pointer.");
        vector<ASTPointer<VariableDeclaration>> const& returnParameters =
            _return.annotation().functionReturnParameters->parameters();
        TypePointers types;
        for (auto const& retVariable: returnParameters)
            types.push_back(retVariable->annotation().type);

        TypePointer expectedType;
        if (expression->annotation().type->category() == Type::Category::Tuple || types.size() != 1)
            expectedType = make_shared<TupleType>(types);
        else
            expectedType = types.front();
        compileExpression(*expression, expectedType);

        for (auto const& retVariable: boost::adaptors::reverse(returnParameters))
            CompilerUtils(m_context).moveToStackVariable(*retVariable);
    }

    CompilerUtils(m_context).popAndJump(m_returnTags.back().second, m_returnTags.back().first);
    return false;
}

bool ContractCompiler::visit(Throw const&)
{
    solAssert(false, "Throw statement is disallowed.");
    return false;
}

bool ContractCompiler::visit(EmitStatement const& _emit)
{
    CompilerContext::LocationSetter locationSetter(m_context, _emit);
    StackHeightChecker checker(m_context);
    compileExpression(_emit.eventCall());
    checker.check();
    return false;
}

bool ContractCompiler::visit(VariableDeclarationStatement const& _variableDeclarationStatement)
{
    CompilerContext::LocationSetter locationSetter(m_context, _variableDeclarationStatement);

    // Local variable slots are reserved when their declaration is visited,
    // and freed in the end of their scope.
    for (auto _decl: _variableDeclarationStatement.declarations())
        if (_decl)
            appendStackVariableInitialisation(*_decl);

    StackHeightChecker checker(m_context);
    if (Expression const* expression = _variableDeclarationStatement.initialValue())
    {
        CompilerUtils utils(m_context);
        compileExpression(*expression);
        TypePointers valueTypes;
        if (auto tupleType = dynamic_cast<TupleType const*>(expression->annotation().type.get()))
            valueTypes = tupleType->components();
        else
            valueTypes = TypePointers{expression->annotation().type};
        auto const& declarations = _variableDeclarationStatement.declarations();
        solAssert(declarations.size() == valueTypes.size(), "");
        for (size_t i = 0; i < declarations.size(); ++i)
        {
            size_t j = declarations.size() - i - 1;
            solAssert(!!valueTypes[j], "");
            if (VariableDeclaration const* varDecl = declarations[j].get())
            {
                utils.convertType(*valueTypes[j], *varDecl->annotation().type);
                utils.moveToStackVariable(*varDecl);
            }
            else
                utils.popStackElement(*valueTypes[j]);
        }
    }
    checker.check();
    return false;
}

bool ContractCompiler::visit(ExpressionStatement const& _expressionStatement)
{
    StackHeightChecker checker(m_context);
    CompilerContext::LocationSetter locationSetter(m_context, _expressionStatement);
    Expression const& expression = _expressionStatement.expression();
    compileExpression(expression);
    CompilerUtils(m_context).popStackElement(*expression.annotation().type);
    checker.check();
    return false;
}

bool ContractCompiler::visit(PlaceholderStatement const& _placeholderStatement)
{
    StackHeightChecker checker(m_context);
    CompilerContext::LocationSetter locationSetter(m_context, _placeholderStatement);
    appendModifierOrFunctionCode();
    checker.check();
    return true;
}

bool ContractCompiler::visit(Block const& _block)
{
    storeStackHeight(&_block);
    return true;
}

void ContractCompiler::endVisit(Block const& _block)
{
    // Frees local variables declared in the scope of this block.
    popScopedVariables(&_block);
}

void ContractCompiler::appendMissingFunctions()
{
    while (Declaration const* function = m_context.nextFunctionToCompile())
    {
        m_context.setStackOffset(0);
        function->accept(*this);
        solAssert(m_context.nextFunctionToCompile() != function, "Compiled the wrong function?");
    }
    m_context.appendMissingLowLevelFunctions();
    string abiFunctions = m_context.abiFunctions().requestedFunctions();
    if (!abiFunctions.empty())
        m_context.appendInlineAssembly("{" + move(abiFunctions) + "}", {}, true);
}

void ContractCompiler::appendModifierOrFunctionCode()
{
    solAssert(m_currentFunction, "");
    unsigned stackSurplus = 0;
    Block const* codeBlock = nullptr;
    vector<VariableDeclaration const*> addedVariables;

    m_modifierDepth++;

    if (m_modifierDepth >= m_currentFunction->modifiers().size())
    {
        solAssert(m_currentFunction->isImplemented(), "");
        codeBlock = &m_currentFunction->body();
    }
    else
    {
        ASTPointer<ModifierInvocation> const& modifierInvocation = m_currentFunction->modifiers()[m_modifierDepth];

        // constructor call should be excluded
        if (dynamic_cast<ContractDefinition const*>(modifierInvocation->name()->annotation().referencedDeclaration))
            appendModifierOrFunctionCode();
        else
        {
            ModifierDefinition const& nonVirtualModifier = dynamic_cast<ModifierDefinition const&>(
                *modifierInvocation->name()->annotation().referencedDeclaration
            );
            ModifierDefinition const& modifier = m_context.resolveVirtualFunctionModifier(nonVirtualModifier);
            CompilerContext::LocationSetter locationSetter(m_context, modifier);
            std::vector<ASTPointer<Expression>> const& modifierArguments =
                modifierInvocation->arguments() ? *modifierInvocation->arguments() : std::vector<ASTPointer<Expression>>();

            solAssert(modifier.parameters().size() == modifierArguments.size(), "");
            for (unsigned i = 0; i < modifier.parameters().size(); ++i)
            {
                m_context.addVariable(*modifier.parameters()[i]);
                addedVariables.push_back(modifier.parameters()[i].get());
                compileExpression(
                    *modifierArguments[i],
                    modifier.parameters()[i]->annotation().type
                );
            }

            stackSurplus = CompilerUtils::sizeOnStack(modifier.parameters());
            codeBlock = &modifier.body();
        }
    }

    if (codeBlock)
    {
        m_returnTags.push_back({m_context.newTag(), m_context.stackHeight()});
        codeBlock->accept(*this);

        solAssert(!m_returnTags.empty(), "");
        m_context << m_returnTags.back().first;
        m_returnTags.pop_back();

        CompilerUtils(m_context).popStackSlots(stackSurplus);
        for (auto var: addedVariables)
            m_context.removeVariable(*var);
    }
    m_modifierDepth--;
}

void ContractCompiler::appendStackVariableInitialisation(VariableDeclaration const& _variable)
{
    CompilerContext::LocationSetter location(m_context, _variable);
    m_context.addVariable(_variable);
    CompilerUtils(m_context).pushZeroValue(*_variable.annotation().type);
}

void ContractCompiler::compileExpression(Expression const& _expression, TypePointer const& _targetType)
{
    ExpressionCompiler expressionCompiler(m_context, m_optimise);
    expressionCompiler.compile(_expression);
    if (_targetType)
        CompilerUtils(m_context).convertType(*_expression.annotation().type, *_targetType);
}

void ContractCompiler::popScopedVariables(ASTNode const* _node)
{
    unsigned blockHeight = m_scopeStackHeight.at(m_modifierDepth).at(_node);
    m_context.removeVariablesAboveStackHeight(blockHeight);
    solAssert(m_context.stackHeight() >= blockHeight, "");
    unsigned stackDiff = m_context.stackHeight() - blockHeight;
    CompilerUtils(m_context).popStackSlots(stackDiff);
    m_scopeStackHeight[m_modifierDepth].erase(_node);
    if (m_scopeStackHeight[m_modifierDepth].size() == 0)
        m_scopeStackHeight.erase(m_modifierDepth);
}

void ContractCompiler::storeStackHeight(ASTNode const* _node)
{
    m_scopeStackHeight[m_modifierDepth][_node] = m_context.stackHeight();
}