path: root/libsolidity/inlineasm/AsmCodeGen.cpp

/*
    This file is part of cpp-ethereum.

    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
 * @author Christian <c@ethdev.com>
 * @date 2016
 * Code-generating part of inline assembly.
 */

#include <libsolidity/inlineasm/AsmCodeGen.h>
#include <memory>
#include <functional>
#include <libevmasm/Assembly.h>
#include <libevmasm/SourceLocation.h>
#include <libevmasm/Instruction.h>
#include <libsolidity/inlineasm/AsmParser.h>
#include <libsolidity/inlineasm/AsmData.h>

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

struct GeneratorState
{
    explicit GeneratorState(ErrorList& _errors): errors(_errors) {}

    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);
    }

    int const* findVariable(string const& _variableName) const
    {
        auto localVariable = find_if(
            variables.rbegin(),
            variables.rend(),
            [&](pair<string, int> const& _var) { return _var.first == _variableName; }
        );
        return localVariable != variables.rend() ? &localVariable->second : nullptr;
    }
    eth::AssemblyItem const* findLabel(string const& _labelName) 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;
    }

    eth::Assembly assembly;
    map<string, eth::AssemblyItem> labels;
    vector<pair<string, int>> variables; ///< name plus stack height
    ErrorList& errors;
};

/**
 * 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) {}

    template <class T>
    void operator()(T const& /*_item*/) { }
    void operator()(Label const& _item)
    {
        if (m_state.labels.count(_item.name))
            //@TODO location and secondary location
            m_state.addError(Error::Type::DeclarationError, "Label " + _item.name + " declared twice.");
        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:
    /// Create the code transformer which appends assembly to _state.assembly when called
    /// with parsed assembly data.
    /// @param _identifierAccess used to resolve identifiers external to the inline assembly
    explicit CodeTransform(
        GeneratorState& _state,
        assembly::CodeGenerator::IdentifierAccess const& _identifierAccess = assembly::CodeGenerator::IdentifierAccess()
    ):
        m_state(_state)
    {
        if (_identifierAccess)
            m_identifierAccess = _identifierAccess;
        else
            m_identifierAccess = [](assembly::Identifier const&, eth::Assembly&, CodeGenerator::IdentifierContext) { return false; };
    }

    void operator()(dev::solidity::assembly::Instruction const& _instruction)
    {
        m_state.assembly.append(_instruction.instruction);
    }
    void operator()(assembly::Literal const& _literal)
    {
        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)"
            );
        else
            m_state.assembly.append(_literal.value);
    }
    void operator()(assembly::Identifier const& _identifier)
    {
        // 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)
                //@TODO location
                m_state.addError(
                    Error::Type::TypeError,
                    "Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")"
                );
            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,
                "Identifier \"" + string(_identifier.name) + "\" not found or not unique"
            );
    }
    void operator()(FunctionalInstruction const& _instr)
    {
        for (auto it = _instr.arguments.rbegin(); it != _instr.arguments.rend(); ++it)
        {
            int height = m_state.assembly.deposit();
            boost::apply_visitor(*this, *it);
            expectDeposit(1, height);
        }
        (*this)(_instr.instruction);
    }
    void operator()(Label const& _label)
    {
        m_state.assembly.append(m_state.labels.at(_label.name));
    }
    void operator()(assembly::Assignment const& _assignment)
    {
        generateAssignment(_assignment.variableName);
    }
    void operator()(FunctionalAssignment const& _assignment)
    {
        int height = m_state.assembly.deposit();
        boost::apply_visitor(*this, *_assignment.value);
        expectDeposit(1, height);
        generateAssignment(_assignment.variableName);
    }
    void operator()(assembly::VariableDeclaration const& _varDecl)
    {
        int height = m_state.assembly.deposit();
        boost::apply_visitor(*this, *_varDecl.value);
        expectDeposit(1, height);
        m_state.variables.push_back(make_pair(_varDecl.name, height));
    }
    void operator()(assembly::Block const& _block)
    {
        size_t numVariables = m_state.variables.size();
        std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
        // pop variables
        //@TODO check height before and after
        while (m_state.variables.size() > numVariables)
        {
            m_state.assembly.append(solidity::Instruction::POP);
            m_state.variables.pop_back();
        }
    }

private:
    void generateAssignment(assembly::Identifier const& _variableName)
    {
        if (int const* stackHeight = m_state.findVariable(_variableName.name))
        {
            int heightDiff = m_state.assembly.deposit() - *stackHeight - 1;
            if (heightDiff <= 0 || heightDiff > 16)
                //@TODO location
                m_state.addError(
                    Error::Type::TypeError,
                    "Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")"
                );
            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_state.addError(
                Error::Type::DeclarationError,
                "Identifier \"" + string(_variableName.name) + "\" not found, not unique or not lvalue."
            );
    }

    void expectDeposit(int _deposit, int _oldHeight)
    {
        if (m_state.assembly.deposit() != _oldHeight + 1)
            //@TODO location
            m_state.addError(Error::Type::TypeError,
                "Expected instruction(s) to deposit " +
                boost::lexical_cast<string>(_deposit) +
                " item(s) to the stack, but did deposit " +
                boost::lexical_cast<string>(m_state.assembly.deposit() - _oldHeight) +
                " item(s)."
            );
    }

    GeneratorState& m_state;
    assembly::CodeGenerator::IdentifierAccess m_identifierAccess;
};

bool assembly::CodeGenerator::typeCheck(assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
{
    size_t initialErrorLen = m_errors.size();
    GeneratorState state(m_errors);
    (LabelOrganizer(state))(m_parsedData);
    (CodeTransform(state, _identifierAccess))(m_parsedData);
    return m_errors.size() == initialErrorLen;
}

eth::Assembly assembly::CodeGenerator::assemble(assembly::CodeGenerator::IdentifierAccess const& _identifierAccess)
{
    GeneratorState state(m_errors);
    (LabelOrganizer(state))(m_parsedData);
    (CodeTransform(state, _identifierAccess))(m_parsedData);
    return state.assembly;
}