VMFactory.cpp

Go to the documentation of this file.

/*
    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/>.
*/
 
#include "VMFactory.h"
#include "EVMC.h"
#include "LegacyVM.h"
 
#include <libaleth-interpreter/interpreter.h>
 
#include <evmc/loader.h>
 
namespace po = boost::program_options;
 
namespace dev
{
namespace eth
{
namespace
{
auto g_kind = VMKind::Legacy;
 
std::unique_ptr<EVMC> g_evmcDll;
 
struct VMKindTableEntry
{
    VMKind kind;
    const char* name;
};
 
VMKindTableEntry vmKindsTable[] = {
    {VMKind::Interpreter, "interpreter"},
    {VMKind::Legacy, "legacy"},
};
 
void setVMKind(const std::string& _name)
{
    for (auto& entry : vmKindsTable)
    {
        // Try to find a match in the table of VMs.
        if (_name == entry.name)
        {
            g_kind = entry.kind;
            return;
        }
    }
 
    // If no match for predefined VM names, try loading it as an EVMC VM DLL.
    g_kind = VMKind::DLL;
 
    // Release previous instance
    g_evmcDll.reset();
 
    evmc_loader_error_code ec;
    evmc_instance *instance = evmc_load_and_create(_name.c_str(), &ec);
    assert(ec == EVMC_LOADER_SUCCESS || instance == nullptr);
 
    switch (ec)
    {
    case EVMC_LOADER_SUCCESS:
        break;
    case EVMC_LOADER_CANNOT_OPEN:
        BOOST_THROW_EXCEPTION(
            po::validation_error(po::validation_error::invalid_option_value, "vm", _name, 1));
    case EVMC_LOADER_SYMBOL_NOT_FOUND:
        BOOST_THROW_EXCEPTION(std::system_error(std::make_error_code(std::errc::invalid_seek),
            "loading " + _name + " failed: EVMC create function not found"));
    case EVMC_LOADER_ABI_VERSION_MISMATCH:
        BOOST_THROW_EXCEPTION(std::system_error(std::make_error_code(std::errc::invalid_argument),
            "loading " + _name + " failed: EVMC ABI version mismatch"));
    default:
        BOOST_THROW_EXCEPTION(
            std::system_error(std::error_code(static_cast<int>(ec), std::generic_category()),
                "loading " + _name + " failed"));
    }
 
    g_evmcDll.reset(new EVMC{instance});
 
    cnote << "Loaded EVMC module: " << g_evmcDll->name() << " " << g_evmcDll->version() << " ("
          << _name << ")";
}
}  // namespace
 
namespace
{
const char c_evmcPrefix[] = "evmc ";
 
std::vector<std::pair<std::string, std::string>> s_evmcOptions;
 
void parseEvmcOptions(const std::vector<std::string>& _opts)
{
    for (auto& s : _opts)
    {
        auto separatorPos = s.find('=');
        if (separatorPos == s.npos)
            throw po::invalid_syntax{po::invalid_syntax::missing_parameter, c_evmcPrefix + s};
        auto name = s.substr(0, separatorPos);
        auto value = s.substr(separatorPos + 1);
        s_evmcOptions.emplace_back(std::move(name), std::move(value));
    }
}
}  // namespace
 
std::vector<std::pair<std::string, std::string>>& evmcOptions() noexcept
{
    return s_evmcOptions;
};
 
po::options_description vmProgramOptions(unsigned _lineLength)
{
    // It must be a static object because boost expects const char*.
    static const std::string description = [] {
        std::string names;
        for (auto& entry : vmKindsTable)
        {
            if (!names.empty())
                names += ", ";
            names += entry.name;
        }
 
        return "Select VM implementation. Available options are: " + names + ".";
    }();
 
    po::options_description opts("VM OPTIONS", _lineLength);
    auto add = opts.add_options();
 
    add("vm",
        po::value<std::string>()
            ->value_name("<name>|<path>")
            ->default_value("legacy")
            ->notifier(setVMKind),
        description.data());
 
    add(c_evmcPrefix,
        po::value<std::vector<std::string>>()
            ->multitoken()
            ->value_name("<option>=<value>")
            ->notifier(parseEvmcOptions),
        "EVMC option\n");
 
    return opts;
}
 
 
VMPtr VMFactory::create()
{
    return create(g_kind);
}
 
VMPtr VMFactory::create(VMKind _kind)
{
    static const auto default_delete = [](VMFace * _vm) noexcept { delete _vm; };
    static const auto null_delete = [](VMFace*) noexcept {};
 
    switch (_kind)
    {
    case VMKind::Interpreter:
        return {new EVMC{evmc_create_interpreter()}, default_delete};
    case VMKind::DLL:
        assert(g_evmcDll != nullptr);
        // Return "fake" owning pointer to global EVMC DLL VM.
        return {g_evmcDll.get(), null_delete};
    case VMKind::Legacy:
    default:
        return {new LegacyVM, default_delete};
    }
}
}  // namespace eth
}  // namespace dev