apply_context.cpp
action_trace apply_context::exec_one()
{
control.get_wasm_interface().apply(a.code_version, a.code, *this);
}
wasm_interface.cpp
void wasm_interface::apply( const digest_type& code_id, const shared_string& code, apply_context& context ) {
my->get_instantiated_module(code_id, code, context.trx_context)->apply(context);
}
wasm_interface_private.hpp
struct wasm_interface_impl {
std::unique_ptr<wasm_instantiated_module_interface>& get_instantiated_module( const digest_type& code_id,
const shared_string& code,
transaction_context& trx_context )
{
it = instantiation_cache.emplace(code_id, runtime_interface->instantiate_module((const char*)bytes.data(), bytes.size(), parse_initial_memory(module))).first;
}
binaryen.cpp
class binaryen_instantiated_module : public wasm_instantiated_module_interface {
void apply(apply_context& context) override {
LiteralList args = {Literal(uint64_t(context.receiver)),
Literal(uint64_t(context.act.account)),
Literal(uint64_t(context.act.name))};
call("apply", args, context);
}
void call(const string& entry_point, LiteralList& args, apply_context& context){
const unsigned initial_memory_size = _module->memory.initial*Memory::kPageSize;
interpreter_interface local_interface(_shared_linear_memory, _table, _import_lut, initial_memory_size, context);
//zero out the initial pages
memset(_shared_linear_memory.data, 0, initial_memory_size);
//copy back in the initial data
memcpy(_shared_linear_memory.data, _initial_memory.data(), _initial_memory.size());
//be aware that construction of the ModuleInstance implictly fires the start function
ModuleInstance instance(*_module.get(), &local_interface);
instance.callExport(Name(entry_point), args);
}
}
std::unique_ptr<wasm_instantiated_module_interface> binaryen_runtime::instantiate_module(const char* code_bytes, size_t code_size, std::vector<uint8_t> initial_memory) {
try {
return std::make_unique<binaryen_instantiated_module>(_memory, initial_memory, move(table), move(import_lut), move(module))
}
binaryen.hpp
struct interpreter_interface : ModuleInstance::ExternalInterface {
}
class binaryen_runtime : public eosio::chain::wasm_runtime_interface {
}
wasm-interpreter.h
template<typename GlobalManager, typename SubType>
class ModuleInstanceBase {
Module& wasm;
ExternalInterface* externalInterface;
};
class ModuleInstance : public ModuleInstanceBase<TrivialGlobalManager, ModuleInstance> {
public:
ModuleInstance(Module& wasm, ExternalInterface* externalInterface) : ModuleInstanceBase(wasm, externalInterface) {}
};