sysio::vm::jit_execution_context< Host, EnableBacktrace > Class Template Reference

#include <execution_context.hpp>

Inheritance diagram for sysio::vm::jit_execution_context< Host, EnableBacktrace >:

Collaboration diagram for sysio::vm::jit_execution_context< Host, EnableBacktrace >:

Public Member Functions
	jit_execution_context (module &m, std::uint32_t max_call_depth)
void	set_max_call_depth (std::uint32_t max_call_depth)
native_value	call_host_function (native_value *stack, uint32_t index)
void	reset ()
template<typename... Args>
std::optional< operand_stack_elem >	execute (host_type *host, jit_visitor, uint32_t func_index, Args... args)
	jit_execution_context (module &m, std::uint32_t max_call_depth)
void	set_max_call_depth (std::uint32_t max_call_depth)
native_value	call_host_function (native_value *stack, uint32_t index)
void	reset ()
template<typename... Args>
std::optional< operand_stack_elem >	execute (host_type *host, jit_visitor, uint32_t func_index, Args... args)
template<typename Visitor , typename... Args>
std::optional< operand_stack_elem >	execute (host_type *host, Visitor &&visitor, const std::string_view func, Args... args)
auto &	get_operand_stack ()
const auto &	get_operand_stack () const
char *	linear_memory ()
auto	get_interface ()
Public Member Functions inherited from sysio::vm::execution_context_base< jit_execution_context< Host, false >, Host >
jit_execution_context< Host, false > &	derived ()
jit_execution_context< Host, false > &	derived ()
	execution_context_base (module &m)
	execution_context_base (module &m)
int32_t	grow_linear_memory (int32_t pages)
int32_t	grow_linear_memory (int32_t pages)
int32_t	current_linear_memory () const
int32_t	current_linear_memory () const
void	exit (std::error_code err=std::error_code())
void	exit (std::error_code err=std::error_code())
module &	get_module ()
module &	get_module ()
void	set_wasm_allocator (wasm_allocator *alloc)
void	set_wasm_allocator (wasm_allocator *alloc)
auto	get_wasm_allocator ()
auto	get_wasm_allocator ()
char *	linear_memory ()
char *	linear_memory ()
auto &	get_operand_stack ()
const auto &	get_operand_stack () const
auto &	get_operand_stack ()
const auto &	get_operand_stack () const
auto	get_interface ()
auto	get_interface ()
void	set_max_pages (std::uint32_t max_pages)
void	set_max_pages (std::uint32_t max_pages)
std::error_code	get_error_code () const
std::error_code	get_error_code () const
void	reset ()
void	reset ()
std::optional< operand_stack_elem >	execute (host_type *host, Visitor &&visitor, const std::string_view func, Args... args)
std::optional< operand_stack_elem >	execute (host_type *host, Visitor &&visitor, const std::string_view func, Args... args)
void	execute_start (host_type *host, Visitor &&visitor)
void	execute_start (host_type *host, Visitor &&visitor)

Static Public Member Functions
static void	handle_signal (int sig)

Public Attributes
module &	_mod
detail::host_invoker_t< Host >	_rhf
std::error_code	_error_code

Protected Member Functions
template<typename T >
native_value	transform_arg (T &&value)
template<typename T >
native_value	transform_arg (T &&value)

Protected Attributes
host_type *	_host = nullptr
uint32_t	_remaining_call_depth
Protected Attributes inherited from sysio::vm::execution_context_base< jit_execution_context< Host, false >, Host >
char *	_linear_memory
module &	_mod
wasm_allocator *	_wasm_alloc
uint32_t	_max_pages
detail::host_invoker_t< Host >	_rhf
std::error_code	_error_code
operand_stack	_os

Additional Inherited Members
Static Protected Member Functions inherited from sysio::vm::execution_context_base< jit_execution_context< Host, false >, Host >
static void	type_check_args (const func_type &ft, Args &&...)
static void	type_check_args (const func_type &ft, Args &&...)
static void	handle_signal (int sig)
static void	handle_signal (int sig)

Detailed Description

template<typename Host, bool EnableBacktrace = false>
class sysio::vm::jit_execution_context< Host, EnableBacktrace >

Definition at line 212 of file execution_context.hpp.

Constructor & Destructor Documentation

jit_execution_context() [1/2]

template<typename Host , bool EnableBacktrace = false>

sysio::vm::jit_execution_context< Host, EnableBacktrace >::jit_execution_context ( module & m, std::uint32_t max_call_depth )

inline

Definition at line 226 of file execution_context.hpp.

: base_type(m), _remaining_call_depth(max_call_depth) {}

jit_execution_context() [2/2]

template<typename Host , bool EnableBacktrace = false>

sysio::vm::jit_execution_context< Host, EnableBacktrace >::jit_execution_context ( module & m, std::uint32_t max_call_depth )

inline

Definition at line 226 of file execution_context.hpp.

: base_type(m), _remaining_call_depth(max_call_depth) {}

Member Function Documentation

call_host_function() [1/2]

template<typename Host , bool EnableBacktrace = false>

native_value sysio::vm::jit_execution_context< Host, EnableBacktrace >::call_host_function ( native_value * stack, uint32_t index )

inline

Definition at line 232 of file execution_context.hpp.

                                                                                  {
         const auto& ft = _mod.get_function_type(index);
         uint32_t num_params = ft.param_types.size();
#ifndef NDEBUG
         uint32_t original_operands = get_operand_stack().size();
#endif
         for(uint32_t i = 0; i < ft.param_types.size(); ++i) {
            switch(ft.param_types[i]) {
             case i32: get_operand_stack().push(i32_const_t{stack[num_params - i - 1].i32}); break;
             case i64: get_operand_stack().push(i64_const_t{stack[num_params - i - 1].i64}); break;
             case f32: get_operand_stack().push(f32_const_t{stack[num_params - i - 1].f32}); break;
             case f64: get_operand_stack().push(f64_const_t{stack[num_params - i - 1].f64}); break;
             default: assert(!"Unexpected type in param_types.");
            }
         }
         _rhf(_host, get_interface(), _mod.import_functions[index]);
         native_value result{uint64_t{0}};
         // guarantee that the junk bits are zero, to avoid problems.
         auto set_result = [&result](auto val) { std::memcpy(&result, &val, sizeof(val)); };
         if(ft.return_count) {
            operand_stack_elem el = get_operand_stack().pop();
            switch(ft.return_type) {
             case i32: set_result(el.to_ui32()); break;
             case i64: set_result(el.to_ui64()); break;
             case f32: set_result(el.to_f32()); break;
             case f64: set_result(el.to_f64()); break;
             default: assert(!"Unexpected function return type.");
            }
         }
 
         assert(get_operand_stack().size() == original_operands);
         return result;
      }

Here is the call graph for this function:

call_host_function() [2/2]

template<typename Host , bool EnableBacktrace = false>

native_value sysio::vm::jit_execution_context< Host, EnableBacktrace >::call_host_function ( native_value * stack, uint32_t index )

inline

Definition at line 232 of file execution_context.hpp.

                                                                                  {
         const auto& ft = _mod.get_function_type(index);
         uint32_t num_params = ft.param_types.size();
#ifndef NDEBUG
         uint32_t original_operands = get_operand_stack().size();
#endif
         for(uint32_t i = 0; i < ft.param_types.size(); ++i) {
            switch(ft.param_types[i]) {
             case i32: get_operand_stack().push(i32_const_t{stack[num_params - i - 1].i32}); break;
             case i64: get_operand_stack().push(i64_const_t{stack[num_params - i - 1].i64}); break;
             case f32: get_operand_stack().push(f32_const_t{stack[num_params - i - 1].f32}); break;
             case f64: get_operand_stack().push(f64_const_t{stack[num_params - i - 1].f64}); break;
             default: assert(!"Unexpected type in param_types.");
            }
         }
         _rhf(_host, get_interface(), _mod.import_functions[index]);
         native_value result{uint64_t{0}};
         // guarantee that the junk bits are zero, to avoid problems.
         auto set_result = [&result](auto val) { std::memcpy(&result, &val, sizeof(val)); };
         if(ft.return_count) {
            operand_stack_elem el = get_operand_stack().pop();
            switch(ft.return_type) {
             case i32: set_result(el.to_ui32()); break;
             case i64: set_result(el.to_ui64()); break;
             case f32: set_result(el.to_f32()); break;
             case f64: set_result(el.to_f64()); break;
             default: assert(!"Unexpected function return type.");
            }
         }
 
         assert(get_operand_stack().size() == original_operands);
         return result;
      }

Here is the call graph for this function:

execute() [1/3]

template<typename Host , bool EnableBacktrace = false>

template<typename... Args>

std::optional< operand_stack_elem > sysio::vm::jit_execution_context< Host, EnableBacktrace >::execute ( host_type * host, jit_visitor , uint32_t func_index, Args... args )

inline

Definition at line 272 of file execution_context.hpp.

                                                                                                                      {
         auto saved_host = _host;
         auto saved_os_size = get_operand_stack().size();
         auto g = scope_guard([&](){ _host = saved_host; get_operand_stack().eat(saved_os_size); });
 
         _host = host;
 
         const func_type& ft = _mod.get_function_type(func_index);
         this->type_check_args(ft, static_cast<Args&&>(args)...);
         native_value result;
         native_value args_raw[] = { transform_arg(static_cast<Args&&>(args))... };
 
         try {
            if (func_index < _mod.get_imported_functions_size()) {
               std::reverse(args_raw + 0, args_raw + sizeof...(Args));
               result = call_host_function(args_raw, func_index);
            } else {
               std::size_t maximum_stack_usage =
                  (_mod.maximum_stack + 2 /*frame ptr + return ptr*/) * (_remaining_call_depth + 1) +
                 sizeof...(Args) + 4 /* scratch space */;
               stack_allocator alt_stack(maximum_stack_usage * sizeof(native_value));
               // reserve 24 bytes for data accessed by inline assembly
               void* stack = alt_stack.top();
               if(stack) {
                  stack = static_cast<char*>(stack) - 24;
               }
               auto fn = reinterpret_cast<native_value (*)(void*, void*)>(_mod.code[func_index - _mod.get_imported_functions_size()].jit_code_offset + _mod.allocator._code_base);
 
               if constexpr(EnableBacktrace) {
                  sigset_t block_mask;
                  sigemptyset(&block_mask);
                  sigaddset(&block_mask, SIGPROF);
                  pthread_sigmask(SIG_BLOCK, &block_mask, nullptr);
                  auto restore = scope_guard{[this, &block_mask] {
                     this->_top_frame = nullptr;
                     this->_bottom_frame = nullptr;
                     pthread_sigmask(SIG_UNBLOCK, &block_mask, nullptr);
                  }};
 
                  vm::invoke_with_signal_handler([&]() {
                     result = execute<sizeof...(Args)>(args_raw, fn, this, base_type::linear_memory(), stack);
                  }, &handle_signal);
               } else {
                  vm::invoke_with_signal_handler([&]() {
                     result = execute<sizeof...(Args)>(args_raw, fn, this, base_type::linear_memory(), stack);
                  }, &handle_signal);
               }
            }
         } catch(wasm_exit_exception&) {
            return {};
         }
 
         if(!ft.return_count)
            return {};
         else switch (ft.return_type) {
            case i32: return {i32_const_t{result.i32}};
            case i64: return {i64_const_t{result.i64}};
            case f32: return {f32_const_t{result.f32}};
            case f64: return {f64_const_t{result.f64}};
            default: assert(!"Unexpected function return type");
         }
         __builtin_unreachable();
      }

Here is the call graph for this function:

execute() [2/3]

template<typename Host , bool EnableBacktrace = false>

template<typename... Args>

std::optional< operand_stack_elem > sysio::vm::jit_execution_context< Host, EnableBacktrace >::execute ( host_type * host, jit_visitor , uint32_t func_index, Args... args )

inline

Definition at line 272 of file execution_context.hpp.

                                                                                                                      {
         auto saved_host = _host;
         auto saved_os_size = get_operand_stack().size();
         auto g = scope_guard([&](){ _host = saved_host; get_operand_stack().eat(saved_os_size); });
 
         _host = host;
 
         const func_type& ft = _mod.get_function_type(func_index);
         this->type_check_args(ft, static_cast<Args&&>(args)...);
         native_value result;
         native_value args_raw[] = { transform_arg(static_cast<Args&&>(args))... };
 
         try {
            if (func_index < _mod.get_imported_functions_size()) {
               std::reverse(args_raw + 0, args_raw + sizeof...(Args));
               result = call_host_function(args_raw, func_index);
            } else {
               std::size_t maximum_stack_usage =
                  (_mod.maximum_stack + 2 /*frame ptr + return ptr*/) * (_remaining_call_depth + 1) +
                 sizeof...(Args) + 4 /* scratch space */;
               stack_allocator alt_stack(maximum_stack_usage * sizeof(native_value));
               // reserve 24 bytes for data accessed by inline assembly
               void* stack = alt_stack.top();
               if(stack) {
                  stack = static_cast<char*>(stack) - 24;
               }
               auto fn = reinterpret_cast<native_value (*)(void*, void*)>(_mod.code[func_index - _mod.get_imported_functions_size()].jit_code_offset + _mod.allocator._code_base);
 
               if constexpr(EnableBacktrace) {
                  sigset_t block_mask;
                  sigemptyset(&block_mask);
                  sigaddset(&block_mask, SIGPROF);
                  pthread_sigmask(SIG_BLOCK, &block_mask, nullptr);
                  auto restore = scope_guard{[this, &block_mask] {
                     this->_top_frame = nullptr;
                     this->_bottom_frame = nullptr;
                     pthread_sigmask(SIG_UNBLOCK, &block_mask, nullptr);
                  }};
 
                  vm::invoke_with_signal_handler([&]() {
                     result = execute<sizeof...(Args)>(args_raw, fn, this, base_type::linear_memory(), stack);
                  }, &handle_signal);
               } else {
                  vm::invoke_with_signal_handler([&]() {
                     result = execute<sizeof...(Args)>(args_raw, fn, this, base_type::linear_memory(), stack);
                  }, &handle_signal);
               }
            }
         } catch(wasm_exit_exception&) {
            return {};
         }
 
         if(!ft.return_count)
            return {};
         else switch (ft.return_type) {
            case i32: return {i32_const_t{result.i32}};
            case i64: return {i64_const_t{result.i64}};
            case f32: return {f32_const_t{result.f32}};
            case f64: return {f64_const_t{result.f64}};
            default: assert(!"Unexpected function return type");
         }
         __builtin_unreachable();
      }

Here is the call graph for this function:

execute() [3/3]

template<typename Host , bool EnableBacktrace = false>

template<typename Visitor , typename... Args>

std::optional< operand_stack_elem > sysio::vm::execution_context_base< Derived, Host >::execute ( host_type * host, Visitor && visitor, const std::string_view func, Args... args )

inline

Definition at line 151 of file execution_context.hpp.

                                                             {
         uint32_t func_index = _mod.get_exported_function(func);
         return derived().execute(host, std::forward<Visitor>(visitor), func_index, std::forward<Args>(args)...);
      }

get_interface()

template<typename Host , bool EnableBacktrace = false>

auto sysio::vm::execution_context_base< Derived, Host >::get_interface ( )

inline

Definition at line 118 of file execution_context.hpp.

{ return execution_interface{ _linear_memory, &_os }; }

get_operand_stack() [1/2]

template<typename Host , bool EnableBacktrace = false>

auto & sysio::vm::execution_context_base< Derived, Host >::get_operand_stack ( )

inline

Definition at line 116 of file execution_context.hpp.

{ return _os; }

get_operand_stack() [2/2]

template<typename Host , bool EnableBacktrace = false>

const auto & sysio::vm::execution_context_base< Derived, Host >::get_operand_stack ( ) const

inline

Definition at line 117 of file execution_context.hpp.

{ return _os; }

handle_signal()

template<typename Host , bool EnableBacktrace = false>

static void sysio::vm::execution_context_base< Derived, Host >::handle_signal ( int sig )

inlinestatic

Definition at line 172 of file execution_context.hpp.

                                         {
         switch(sig) {
          case SIGSEGV:
          case SIGBUS:
          case SIGFPE:
            break;
          default:
            /* TODO fix this */
            assert(!"??????");
         }
         throw wasm_memory_exception{ "wasm memory out-of-bounds" };
      }

linear_memory()

template<typename Host , bool EnableBacktrace = false>

char * sysio::vm::execution_context_base< Derived, Host >::linear_memory ( )

inline

Definition at line 115 of file execution_context.hpp.

{ return _linear_memory; }

reset() [1/2]

template<typename Host , bool EnableBacktrace = false>

void sysio::vm::jit_execution_context< Host, EnableBacktrace >::reset ( )

inline

Definition at line 266 of file execution_context.hpp.

                          {
         base_type::reset();
         get_operand_stack().eat(0);
      }

reset() [2/2]

template<typename Host , bool EnableBacktrace = false>

void sysio::vm::jit_execution_context< Host, EnableBacktrace >::reset ( )

inline

Definition at line 266 of file execution_context.hpp.

                          {
         base_type::reset();
         get_operand_stack().eat(0);
      }

set_max_call_depth() [1/2]

template<typename Host , bool EnableBacktrace = false>

void sysio::vm::jit_execution_context< Host, EnableBacktrace >::set_max_call_depth ( std::uint32_t max_call_depth )

inline

Definition at line 228 of file execution_context.hpp.

                                                          {
         _remaining_call_depth = max_call_depth;
      }

set_max_call_depth() [2/2]

template<typename Host , bool EnableBacktrace = false>

void sysio::vm::jit_execution_context< Host, EnableBacktrace >::set_max_call_depth ( std::uint32_t max_call_depth )

inline

Definition at line 228 of file execution_context.hpp.

                                                          {
         _remaining_call_depth = max_call_depth;
      }

transform_arg() [1/2]

template<typename Host , bool EnableBacktrace = false>

template<typename T >

native_value sysio::vm::jit_execution_context< Host, EnableBacktrace >::transform_arg ( T && value )

inlineprotected

Definition at line 400 of file execution_context.hpp.

                                            {
         // make sure that the garbage bits are always zero.
         native_value result;
         std::memset(&result, 0, sizeof(result));
         auto tc = detail::type_converter_t<Host>{_host, get_interface()};
         auto transformed_value = detail::resolve_result(tc, static_cast<T&&>(value)).data;
         std::memcpy(&result, &transformed_value, sizeof(transformed_value));
         return result;
      }

transform_arg() [2/2]

template<typename Host , bool EnableBacktrace = false>

template<typename T >

native_value sysio::vm::jit_execution_context< Host, EnableBacktrace >::transform_arg ( T && value )

inlineprotected

Definition at line 400 of file execution_context.hpp.

                                            {
         // make sure that the garbage bits are always zero.
         native_value result;
         std::memset(&result, 0, sizeof(result));
         auto tc = detail::type_converter_t<Host>{_host, get_interface()};
         auto transformed_value = detail::resolve_result(tc, static_cast<T&&>(value)).data;
         std::memcpy(&result, &transformed_value, sizeof(transformed_value));
         return result;
      }

Member Data Documentation

_error_code

template<typename Host , bool EnableBacktrace = false>

std::error_code sysio::vm::execution_context_base< Derived, Host >::_error_code

Definition at line 190 of file execution_context.hpp.

_host

template<typename Host , bool EnableBacktrace = false>

host_type * sysio::vm::jit_execution_context< Host, EnableBacktrace >::_host = nullptr

protected

Definition at line 478 of file execution_context.hpp.

_mod

template<typename Host , bool EnableBacktrace = false>

module & sysio::vm::execution_context_base< Derived, Host >::_mod

Definition at line 186 of file execution_context.hpp.

_remaining_call_depth

template<typename Host , bool EnableBacktrace = false>

uint32_t sysio::vm::jit_execution_context< Host, EnableBacktrace >::_remaining_call_depth

protected

Definition at line 479 of file execution_context.hpp.

_rhf

template<typename Host , bool EnableBacktrace = false>

detail::host_invoker_t< Host > sysio::vm::execution_context_base< Derived, Host >::_rhf

Definition at line 189 of file execution_context.hpp.

---

The documentation for this class was generated from the following files:

• libraries/sys-vm/include/sysio/sysio/vm/execution_context.hpp
• libraries/sys-vm/include/sysio/vm/execution_context.hpp