sysio::chain::webassembly::eosvmoc Namespace Reference

Classes
struct	eos_vm_oc_execution_interface
struct	eos_vm_oc_type_converter
class	eosvmoc_instantiated_module
class	eosvmoc_runtime
struct	result_resolver
struct	wasm_function_type_provider
struct	wasm_function_type_provider< Ret(Args...)>
struct	wasm_to_rvalue_type
struct	wasm_to_rvalue_type< F32 >
struct	wasm_to_rvalue_type< F64 >
struct	wasm_to_rvalue_type< U32 >
struct	wasm_to_rvalue_type< U64 >
struct	wasm_to_rvalue_type< void >
struct	wasm_to_value_type
struct	wasm_to_value_type< F32 >
struct	wasm_to_value_type< F64 >
struct	wasm_to_value_type< U32 >
struct	wasm_to_value_type< U64 >

Functions
template<typename T >
void *	array_ptr_impl (size_t ptr, size_t length)
char *	null_terminated_ptr_impl (uint64_t ptr)
auto	convert_native_to_wasm (char *ptr)
template<typename Args , std::size_t... Is>
auto	get_ct_args (std::index_sequence< Is... >)
uint32_t	make_native_type (vm::i32_const_t x)
uint64_t	make_native_type (vm::i64_const_t x)
float	make_native_type (vm::f32_const_t x)
double	make_native_type (vm::f64_const_t x)
template<typename TC , typename Args , std::size_t... Is>
auto	get_ct_args_one (std::index_sequence< Is... >)
template<typename TC , typename T >
auto	get_ct_args_i ()
template<auto F, typename Interface , typename Preconditions , bool is_injected, typename... A>
auto	fn (A... a)
template<auto F, typename Preconditions , typename Args , bool is_injected, std::size_t... Is>
constexpr auto	create_function (std::index_sequence< Is... >)
template<auto F, typename Preconditions , bool is_injected>
constexpr auto	create_function ()
template<auto F, bool injected, typename Preconditions , typename Name >
void	register_eosvm_oc (Name n)

Variables
template<typename T >
constexpr auto	wasm_to_value_type_v = wasm_to_value_type<T>::value
template<typename T >
constexpr auto	wasm_to_rvalue_type_v = wasm_to_rvalue_type<T>::value

Function Documentation

array_ptr_impl()

template<typename T >

void * sysio::chain::webassembly::eosvmoc::array_ptr_impl ( size_t ptr, size_t length )

inline

validate an in-wasm-memory array

Template Parameters

T

When a pointer will be invalid we want to stop execution right here right now. This is accomplished by forcing a read from an address that must always be bad. A better approach would probably be to call in to a function that notes the invalid parameter and host function and then bubbles up a more useful error message; maybe some day. Prior to WASM_LIMITS the code just simply did a load from address 33MB via an immediate. 33MB was always invalid since 33MB was the most WASM memory you could have. Post WASM_LIMITS you theoretically could have up to 4GB, but we can't do a load from a 4GB immediate since immediates are limited to signed 32bit ranges.

So instead access the first_invalid_memory_address which by its name will always be invalid. Or will it? No... it won't, since it's initialized to -1*64KB in the case WASM has no memory! We actually cannot clamp first_invalid_memory_address to 0 during initialization in such a case since there is some historical funny business going on when end==0 (note how jle will pass when end==0 & first_invalid_memory_address==0)

So instead just bump first_invalid_memory_address another 64KB before accessing it. If it's -64KB it'll go to 0 which fails correctly in that case. If it's 4GB it'll go to 4GB+64KB which still fails too (there is an entire 8GB range of WASM memory set aside). There are other more straightforward ways of accomplishing this, but at least this approach has zero overhead (e.g. no additional register usage, etc) in the nominal case.

Definition at line 63 of file sys-vm-oc.hpp.

{
   constexpr int cb_full_linear_memory_start_segment_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(full_linear_memory_start);
   constexpr int cb_first_invalid_memory_address_segment_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(first_invalid_memory_address);
 
   size_t end = ptr + length*sizeof(T);
 
   asm volatile("cmp %%gs:%c[firstInvalidMemory], %[End]\n"
                "jle 1f\n"
                "mov %%gs:%c[firstInvalidMemory], %[End]\n"      // sets End with a known failing address
                "add %[sizeOfOneWASMPage], %[End]\n"             // see above comment
                "mov %%gs:(%[End]), %[Ptr]\n"                    // loads from the known failing address
                "1:\n"
                "add %%gs:%c[linearMemoryStart], %[Ptr]\n"
                : [Ptr] "+r" (ptr),
                  [End] "+r" (end)
                : [linearMemoryStart] "i" (cb_full_linear_memory_start_segment_offset),
                  [firstInvalidMemory] "i" (cb_first_invalid_memory_address_segment_offset),
                  [sizeOfOneWASMPage] "i" (wasm_constraints::wasm_page_size)
                : "cc"
               );
 
 
   return (void*)ptr;
}

Here is the caller graph for this function:

convert_native_to_wasm()

auto sysio::chain::webassembly::eosvmoc::convert_native_to_wasm ( char * ptr )

inline

Definition at line 122 of file sys-vm-oc.hpp.

                                              {
   constexpr int cb_full_linear_memory_start_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(full_linear_memory_start);
   char* full_linear_memory_start;
   asm("mov %%gs:%c[fullLinearMemOffset], %[fullLinearMem]\n"
      : [fullLinearMem] "=r" (full_linear_memory_start)
      : [fullLinearMemOffset] "i" (cb_full_linear_memory_start_offset)
      );
   U64 delta = (U64)(ptr - full_linear_memory_start);
   return (U32)delta;
}

Here is the caller graph for this function:

create_function() [1/2]

template<auto F, typename Preconditions , bool is_injected>

auto sysio::chain::webassembly::eosvmoc::create_function ( )

constexpr

Definition at line 376 of file sys-vm-oc.hpp.

                                 {
   using native_args = vm::flatten_parameters_t<AUTO_PARAM_WORKAROUND(F)>;
   using wasm_args = decltype(get_ct_args<native_args>(std::make_index_sequence<std::tuple_size_v<native_args>>()));
   return create_function<F, Preconditions, wasm_args, is_injected>(std::make_index_sequence<std::tuple_size_v<wasm_args>>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_function() [2/2]

template<auto F, typename Preconditions , typename Args , bool is_injected, std::size_t... Is>

auto sysio::chain::webassembly::eosvmoc::create_function ( std::index_sequence< Is... > )

constexpr

Definition at line 371 of file sys-vm-oc.hpp.

                                                         {
   return &fn<F, webassembly::interface, Preconditions, is_injected, std::tuple_element_t<Is, Args>...>;
}

Here is the call graph for this function:

fn()

template<auto F, typename Interface , typename Preconditions , bool is_injected, typename... A>

auto sysio::chain::webassembly::eosvmoc::fn

(

A...

a

)

Definition at line 336 of file sys-vm-oc.hpp.

                {
   try {
      if constexpr(!is_injected) {
         constexpr int cb_current_call_depth_remaining_segment_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(current_call_depth_remaining);
         constexpr int depth_assertion_intrinsic_offset = OFFSET_OF_FIRST_INTRINSIC - (int) find_intrinsic_index("eosvmoc_internal.depth_assert") * 8;
 
         asm volatile("cmpl   $1,%%gs:%c[callDepthRemainOffset]\n"
                      "jne    1f\n"
                      "callq  *%%gs:%c[depthAssertionIntrinsicOffset]\n"
                      "1:\n"
                      :
                      : [callDepthRemainOffset] "i" (cb_current_call_depth_remaining_segment_offset),
                        [depthAssertionIntrinsicOffset] "i" (depth_assertion_intrinsic_offset)
                      : "cc");
      }
      using native_args = vm::flatten_parameters_t<AUTO_PARAM_WORKAROUND(F)>;
      sysio::vm::native_value stack[] = { a... };
      constexpr int cb_ctx_ptr_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(ctx);
      apply_context* ctx;
      asm("mov %%gs:%c[applyContextOffset], %[cPtr]\n"
          : [cPtr] "=r" (ctx)
          : [applyContextOffset] "i" (cb_ctx_ptr_offset)
          );
      Interface host(*ctx);
      eos_vm_oc_type_converter tc{&host, eos_vm_oc_execution_interface{stack + sizeof...(A)}};
      return result_resolver{tc}, sysio::vm::invoke_with_host<F, Preconditions, native_args>(tc, &host, std::make_index_sequence<sizeof...(A)>());
   }
   catch(...) {
      *reinterpret_cast<std::exception_ptr*>(eos_vm_oc_get_exception_ptr()) = std::current_exception();
   }
   siglongjmp(*eos_vm_oc_get_jmp_buf(), SYSVMOC_EXIT_EXCEPTION);
   __builtin_unreachable();
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_ct_args()

template<typename Args , std::size_t... Is>

auto sysio::chain::webassembly::eosvmoc::get_ct_args

(

std::index_sequence< Is... >

)

Definition at line 321 of file sys-vm-oc.hpp.

                                           {
   return std::tuple_cat(get_ct_args_i<eos_vm_oc_type_converter, std::tuple_element_t<Is, Args>>()...);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_ct_args_i()

template<typename TC , typename T >

auto sysio::chain::webassembly::eosvmoc::get_ct_args_i

(

)

Definition at line 311 of file sys-vm-oc.hpp.

                     {
   if constexpr (vm::detail::has_from_wasm_v<T, TC>) {
      using args_tuple = vm::detail::from_wasm_type_deducer_t<TC, T>;
      return get_ct_args_one<TC, args_tuple>(std::make_index_sequence<std::tuple_size_v<args_tuple>>());
   } else {
      return std::tuple<decltype(make_native_type(std::declval<TC>().as_result(std::declval<T>())))>();
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_ct_args_one()

template<typename TC , typename Args , std::size_t... Is>

auto sysio::chain::webassembly::eosvmoc::get_ct_args_one

(

std::index_sequence< Is... >

)

Definition at line 306 of file sys-vm-oc.hpp.

                                               {
   return std::tuple<decltype(make_native_type(std::declval<TC>().as_result(std::declval<std::tuple_element_t<Is, Args>>())))...>();
}

Here is the caller graph for this function:

make_native_type() [1/4]

float sysio::chain::webassembly::eosvmoc::make_native_type ( vm::f32_const_t x )

inline

Definition at line 302 of file sys-vm-oc.hpp.

{ return x.data.f; }

make_native_type() [2/4]

double sysio::chain::webassembly::eosvmoc::make_native_type ( vm::f64_const_t x )

inline

Definition at line 303 of file sys-vm-oc.hpp.

{ return x.data.f; }

make_native_type() [3/4]

uint32_t sysio::chain::webassembly::eosvmoc::make_native_type ( vm::i32_const_t x )

inline

Definition at line 300 of file sys-vm-oc.hpp.

{ return x.data.ui; }

Here is the caller graph for this function:

make_native_type() [4/4]

uint64_t sysio::chain::webassembly::eosvmoc::make_native_type ( vm::i64_const_t x )

inline

Definition at line 301 of file sys-vm-oc.hpp.

{ return x.data.ui; }

null_terminated_ptr_impl()

char * sysio::chain::webassembly::eosvmoc::null_terminated_ptr_impl ( uint64_t ptr )

inline

validate an in-wasm-memory char array that must be null terminated

Definition at line 92 of file sys-vm-oc.hpp.

{
   constexpr int cb_full_linear_memory_start_segment_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(full_linear_memory_start);
   constexpr int cb_first_invalid_memory_address_segment_offset = OFFSET_OF_CONTROL_BLOCK_MEMBER(first_invalid_memory_address);
 
   char dumpster;
   uint64_t scratch;
 
   asm volatile("mov %%gs:(%[Ptr]), %[Dumpster]\n"                   //probe memory location at ptr to see if valid
                "mov %%gs:%c[firstInvalidMemory], %[Scratch]\n"      //get first invalid memory address
                "cmpb $0, %%gs:-1(%[Scratch])\n"                     //is last byte in valid linear memory 0?
                "je 2f\n"                                            //if so, this will be a null terminated string one way or another
                "mov %[Ptr],%[Scratch]\n"
                "1:\n"                                               //start loop looking for either 0, or until we SEGV
                "inc %[Scratch]\n"
                "cmpb $0,%%gs:-1(%[Scratch])\n"
                "jne 1b\n"
                "2:\n"
                "add %%gs:%c[linearMemoryStart], %[Ptr]\n"           //add address of linear memory 0 to ptr
                : [Ptr] "+r" (ptr),
                  [Dumpster] "=r" (dumpster),
                  [Scratch] "=r" (scratch)
                : [linearMemoryStart] "i" (cb_full_linear_memory_start_segment_offset),
                  [firstInvalidMemory] "i" (cb_first_invalid_memory_address_segment_offset)
                : "cc"
               );
 
   return (char*)ptr;
}

Here is the caller graph for this function:

register_eosvm_oc()

template<auto F, bool injected, typename Preconditions , typename Name >

void sysio::chain::webassembly::eosvmoc::register_eosvm_oc

(

Name

n

)

Definition at line 383 of file sys-vm-oc.hpp.

                               {
   // Has special handling
   if(n == BOOST_HANA_STRING("env.sysio_exit")) return;
   constexpr auto fn = create_function<F, Preconditions, injected>();
   constexpr auto index = find_intrinsic_index(n.c_str());
   intrinsic the_intrinsic(
      n.c_str(),
      wasm_function_type_provider<std::remove_pointer_t<decltype(fn)>>::type(),
      reinterpret_cast<void*>(fn),
      index
   );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

wasm_to_rvalue_type_v

template<typename T >

auto sysio::chain::webassembly::eosvmoc::wasm_to_rvalue_type_v = wasm_to_rvalue_type<T>::value

constexpr

Definition at line 183 of file sys-vm-oc.hpp.

wasm_to_value_type_v

template<typename T >

auto sysio::chain::webassembly::eosvmoc::wasm_to_value_type_v = wasm_to_value_type<T>::value

constexpr

Definition at line 156 of file sys-vm-oc.hpp.