example_vm.cpp

Go to the documentation of this file.

// EVMC: Ethereum Client-VM Connector API.
// Copyright 2016 The EVMC Authors.
// Licensed under the Apache License, Version 2.0.
 
 
#include "example_vm.h"
#include <evmc/evmc.h>
#include <evmc/helpers.h>
#include <evmc/instructions.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
namespace
{
struct ExampleVM : evmc_vm
{
 int verbose = 0; 
 ExampleVM(); 
};
 
void destroy(evmc_vm* instance)
{
 delete static_cast<ExampleVM*>(instance);
}
 
evmc_capabilities_flagset get_capabilities(evmc_vm* /*instance*/)
{
 return EVMC_CAPABILITY_EVM1;
}
 
enum evmc_set_option_result set_option(evmc_vm* instance, const char* name, const char* value)
{
 auto* vm = static_cast<ExampleVM*>(instance);
 if (std::strcmp(name, "verbose") == 0)
 {
 if (value == nullptr)
 return EVMC_SET_OPTION_INVALID_VALUE;
 
 char* end = nullptr;
 auto v = std::strtol(value, &end, 0);
 if (end == value) // Parsing the value failed.
 return EVMC_SET_OPTION_INVALID_VALUE;
 if (v > 9 || v < -1) // Not in the valid range.
 return EVMC_SET_OPTION_INVALID_VALUE;
 vm->verbose = static_cast<int>(v);
 return EVMC_SET_OPTION_SUCCESS;
 }
 
 return EVMC_SET_OPTION_INVALID_NAME;
}
 
struct Stack
{
 evmc_uint256be items[1024] = {}; 
 evmc_uint256be* pointer = items; 
 
 evmc_uint256be pop() { return *--pointer; }
 
 void push(evmc_uint256be value) { *pointer++ = value; }
};
 
struct Memory
{
 uint32_t size = 0; 
 uint8_t data[1024] = {}; 
 
 uint8_t* expand(uint32_t offset, uint32_t region_size)
 {
 uint32_t new_size = offset + region_size;
 if (new_size > sizeof(data))
 return nullptr; // Cannot expand more than fixed max memory size.
 
 if (new_size > size)
 size = new_size; // Update current memory size.
 
 return &data[offset];
 }
 
 bool store(uint32_t offset, const uint8_t* value_data, uint32_t value_size)
 {
 uint8_t* p = expand(offset, value_size);
 if (p == nullptr)
 return false;
 
 std::memcpy(p, value_data, value_size);
 return true;
 }
};
 
inline evmc_uint256be to_uint256(uint32_t x)
{
 evmc_uint256be value = {};
 value.bytes[31] = static_cast<uint8_t>(x);
 value.bytes[30] = static_cast<uint8_t>(x >> 8);
 value.bytes[29] = static_cast<uint8_t>(x >> 16);
 value.bytes[28] = static_cast<uint8_t>(x >> 24);
 return value;
}
 
inline evmc_uint256be to_uint256(evmc_address address)
{
 evmc_uint256be value = {};
 size_t offset = sizeof(value) - sizeof(address);
 std::memcpy(&value.bytes[offset], address.bytes, sizeof(address.bytes));
 return value;
}
 
inline uint32_t to_uint32(evmc_uint256be value)
{
 return (uint32_t{value.bytes[28]} << 24) | (uint32_t{value.bytes[29]} << 16) |
 (uint32_t{value.bytes[30]} << 8) | (uint32_t{value.bytes[31]});
}
 
inline evmc_address to_address(evmc_uint256be value)
{
 evmc_address address = {};
 size_t offset = sizeof(value) - sizeof(address);
 std::memcpy(address.bytes, &value.bytes[offset], sizeof(address.bytes));
 return address;
}
 
 
evmc_result execute(evmc_vm* instance,
 const evmc_host_interface* host,
 evmc_host_context* context,
 enum evmc_revision rev,
 const evmc_message* msg,
 const uint8_t* code,
 size_t code_size)
{
 auto* vm = static_cast<ExampleVM*>(instance);
 
 if (vm->verbose > 0)
 std::puts("execution started\n");
 
 int64_t gas_left = msg->gas;
 Stack stack;
 Memory memory;
 
 for (size_t pc = 0; pc < code_size; ++pc)
 {
 // Check remaining gas, assume each instruction costs 1.
 gas_left -= 1;
 if (gas_left < 0)
 return evmc_make_result(EVMC_OUT_OF_GAS, 0, 0, nullptr, 0);
 
 switch (code[pc])
 {
 default:
 return evmc_make_result(EVMC_UNDEFINED_INSTRUCTION, 0, 0, nullptr, 0);
 
 case OP_STOP:
 return evmc_make_result(EVMC_SUCCESS, gas_left, 0, nullptr, 0);
 
 case OP_ADD:
 {
 uint32_t a = to_uint32(stack.pop());
 uint32_t b = to_uint32(stack.pop());
 uint32_t sum = a + b;
 stack.push(to_uint256(sum));
 break;
 }
 
 case OP_ADDRESS:
 {
 evmc_uint256be value = to_uint256(msg->recipient);
 stack.push(value);
 break;
 }
 
 case OP_CALLDATALOAD:
 {
 uint32_t offset = to_uint32(stack.pop());
 evmc_uint256be value = {};
 
 if (offset < msg->input_size)
 {
 size_t copy_size = std::min(msg->input_size - offset, sizeof(value));
 std::memcpy(value.bytes, &msg->input_data[offset], copy_size);
 }
 
 stack.push(value);
 break;
 }
 
 case OP_NUMBER:
 {
 evmc_uint256be value =
 to_uint256(static_cast<uint32_t>(host->get_tx_context(context).block_number));
 stack.push(value);
 break;
 }
 
 case OP_MSTORE:
 {
 uint32_t index = to_uint32(stack.pop());
 evmc_uint256be value = stack.pop();
 if (!memory.store(index, value.bytes, sizeof(value)))
 return evmc_make_result(EVMC_FAILURE, 0, 0, nullptr, 0);
 break;
 }
 
 case OP_SLOAD:
 {
 evmc_uint256be index = stack.pop();
 evmc_uint256be value = host->get_storage(context, &msg->recipient, &index);
 stack.push(value);
 break;
 }
 
 case OP_SSTORE:
 {
 evmc_uint256be index = stack.pop();
 evmc_uint256be value = stack.pop();
 host->set_storage(context, &msg->recipient, &index, &value);
 break;
 }
 
 case OP_MSIZE:
 {
 evmc_uint256be value = to_uint256(memory.size);
 stack.push(value);
 break;
 }
 
 case OP_PUSH1:
 case OP_PUSH2:
 case OP_PUSH3:
 case OP_PUSH4:
 case OP_PUSH5:
 case OP_PUSH6:
 case OP_PUSH7:
 case OP_PUSH8:
 case OP_PUSH9:
 case OP_PUSH10:
 case OP_PUSH11:
 case OP_PUSH12:
 case OP_PUSH13:
 case OP_PUSH14:
 case OP_PUSH15:
 case OP_PUSH16:
 case OP_PUSH17:
 case OP_PUSH18:
 case OP_PUSH19:
 case OP_PUSH20:
 case OP_PUSH21:
 case OP_PUSH22:
 case OP_PUSH23:
 case OP_PUSH24:
 case OP_PUSH25:
 case OP_PUSH26:
 case OP_PUSH27:
 case OP_PUSH28:
 case OP_PUSH29:
 case OP_PUSH30:
 case OP_PUSH31:
 case OP_PUSH32:
 {
 evmc_uint256be value = {};
 size_t num_push_bytes = size_t{code[pc]} - OP_PUSH1 + 1;
 size_t offset = sizeof(value) - num_push_bytes;
 std::memcpy(&value.bytes[offset], &code[pc + 1], num_push_bytes);
 pc += num_push_bytes;
 stack.push(value);
 break;
 }
 
 case OP_DUP1:
 {
 evmc_uint256be value = stack.pop();
 stack.push(value);
 stack.push(value);
 break;
 }
 
 case OP_CALL:
 {
 evmc_message call_msg = {};
 call_msg.gas = to_uint32(stack.pop());
 call_msg.recipient = to_address(stack.pop());
 call_msg.value = stack.pop();
 
 uint32_t call_input_offset = to_uint32(stack.pop());
 uint32_t call_input_size = to_uint32(stack.pop());
 call_msg.input_data = memory.expand(call_input_offset, call_input_size);
 call_msg.input_size = call_input_size;
 
 uint32_t call_output_offset = to_uint32(stack.pop());
 uint32_t call_output_size = to_uint32(stack.pop());
 uint8_t* call_output_ptr = memory.expand(call_output_offset, call_output_size);
 
 if (call_msg.input_data == nullptr || call_output_ptr == nullptr)
 return evmc_make_result(EVMC_FAILURE, 0, 0, nullptr, 0);
 
 evmc_result call_result = host->call(context, &call_msg);
 
 evmc_uint256be value = to_uint256(call_result.status_code == EVMC_SUCCESS ? 1 : 0);
 stack.push(value);
 
 if (call_output_size > call_result.output_size)
 call_output_size = static_cast<uint32_t>(call_result.output_size);
 memory.store(call_output_offset, call_result.output_data, call_output_size);
 
 if (call_result.release != nullptr)
 call_result.release(&call_result);
 break;
 }
 
 case OP_RETURN:
 {
 uint32_t output_offset = to_uint32(stack.pop());
 uint32_t output_size = to_uint32(stack.pop());
 uint8_t* output_ptr = memory.expand(output_offset, output_size);
 if (output_ptr == nullptr)
 return evmc_make_result(EVMC_FAILURE, 0, 0, nullptr, 0);
 
 return evmc_make_result(EVMC_SUCCESS, gas_left, 0, output_ptr, output_size);
 }
 
 case OP_REVERT:
 {
 if (rev < EVMC_BYZANTIUM)
 return evmc_make_result(EVMC_UNDEFINED_INSTRUCTION, 0, 0, nullptr, 0);
 
 uint32_t output_offset = to_uint32(stack.pop());
 uint32_t output_size = to_uint32(stack.pop());
 uint8_t* output_ptr = memory.expand(output_offset, output_size);
 if (output_ptr == nullptr)
 return evmc_make_result(EVMC_FAILURE, 0, 0, nullptr, 0);
 
 return evmc_make_result(EVMC_REVERT, gas_left, 0, output_ptr, output_size);
 }
 }
 }
 
 return evmc_make_result(EVMC_SUCCESS, gas_left, 0, nullptr, 0);
}
 
 
#if !defined(PROJECT_VERSION)
#define PROJECT_VERSION "0.0.0"
#endif
 
ExampleVM::ExampleVM()
 : evmc_vm{EVMC_ABI_VERSION, "example_vm", PROJECT_VERSION, ::destroy,
 ::execute, ::get_capabilities, ::set_option}
{}
} // namespace
 
extern "C" evmc_vm* evmc_create_example_vm()
{
 return new ExampleVM;
}