sysio::vm::binary_parser< Writer, Options, DebugInfo > Class Template Reference

#include <parser.hpp>

Classes
struct	local_types_t
struct	operand_stack_type_tracker
struct	pc_element_t

Public Types
template<typename T >
using	vec = guarded_vector<T>
using	label_t = decltype(std::declval<Writer>().emit_end())
using	branch_t = decltype(std::declval<Writer>().emit_if())

Public Member Functions
	binary_parser (growable_allocator &alloc, const Options &options=Options{})
int	validate_utf8_code_point (wasm_code_ptr &code)
void	validate_utf8_string (wasm_code_ptr &code, uint32_t bytes)
guarded_vector< uint8_t >	parse_utf8_string (wasm_code_ptr &code, std::uint32_t max_size)
template<typename T >
T	parse_raw (wasm_code_ptr &code)
module &	parse_module (wasm_code &code, module &mod, DebugInfo &debug)
module &	parse_module2 (wasm_code_ptr &code_ptr, size_t sz, module &mod, DebugInfo &debug)
void	parse_module (wasm_code_ptr &code_ptr, size_t sz, module &mod, DebugInfo &debug)
uint32_t	parse_magic (wasm_code_ptr &code)
uint32_t	parse_version (wasm_code_ptr &code)
uint8_t	parse_section_id (wasm_code_ptr &code)
uint32_t	parse_section_payload_len (wasm_code_ptr &code)
void	parse_custom (wasm_code_ptr &code)
void	parse_name_map (wasm_code_ptr &code, guarded_vector< name_assoc > &map)
void	parse_name_section (wasm_code_ptr &code)
void	parse_import_entry (wasm_code_ptr &code, import_entry &entry)
uint8_t	parse_flags (wasm_code_ptr &code)
void	parse_table_type (wasm_code_ptr &code, table_type &tt)
void	parse_global_variable (wasm_code_ptr &code, global_variable &gv)
void	parse_memory_type (wasm_code_ptr &code, memory_type &mt)
void	parse_export_entry (wasm_code_ptr &code, export_entry &entry)
void	parse_func_type (wasm_code_ptr &code, func_type &ft)
void	parse_elem_segment (wasm_code_ptr &code, elem_segment &es)
void	parse_init_expr (wasm_code_ptr &code, init_expr &ie, uint8_t type)
void	parse_function_body (wasm_code_ptr &code, function_body &fb, std::size_t idx)
void	parse_function_body_code (wasm_code_ptr &code, size_t bounds, const detail::max_func_local_bytes_stack_checker< Options > &local_bytes_checker, Writer &code_writer, const func_type &ft, const local_types_t &local_types)
void	parse_data_segment (wasm_code_ptr &code, data_segment &ds)
template<typename Elem , typename ParseFunc >
void	parse_section_impl (wasm_code_ptr &code, vec< Elem > &elems, std::uint32_t max_elements, ParseFunc &&elem_parse)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::type_section, func_type > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::import_section, import_entry > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::function_section, uint32_t > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::table_section, table_type > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::memory_section, memory_type > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::global_section, global_variable > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::export_section, export_entry > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, typename std::enable_if_t< id==section_id::start_section, uint32_t > &start)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::element_section, elem_segment > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::code_section, function_body > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::data_section, data_segment > > &elems)
template<size_t N>
varint< N >	parse_varint (const wasm_code &code, size_t index)
template<size_t N>
varuint< N >	parse_varuint (const wasm_code &code, size_t index)
void	on_mutable_global (uint8_t type)
void	validate_exports () const
	binary_parser (growable_allocator &alloc, const Options &options=Options{})
int	validate_utf8_code_point (wasm_code_ptr &code)
void	validate_utf8_string (wasm_code_ptr &code, uint32_t bytes)
guarded_vector< uint8_t >	parse_utf8_string (wasm_code_ptr &code, std::uint32_t max_size)
template<typename T >
T	parse_raw (wasm_code_ptr &code)
module &	parse_module (wasm_code &code, module &mod, DebugInfo &debug)
module &	parse_module2 (wasm_code_ptr &code_ptr, size_t sz, module &mod, DebugInfo &debug)
void	parse_module (wasm_code_ptr &code_ptr, size_t sz, module &mod, DebugInfo &debug)
uint32_t	parse_magic (wasm_code_ptr &code)
uint32_t	parse_version (wasm_code_ptr &code)
uint8_t	parse_section_id (wasm_code_ptr &code)
uint32_t	parse_section_payload_len (wasm_code_ptr &code)
void	parse_custom (wasm_code_ptr &code)
void	parse_name_map (wasm_code_ptr &code, guarded_vector< name_assoc > &map)
void	parse_name_section (wasm_code_ptr &code)
void	parse_import_entry (wasm_code_ptr &code, import_entry &entry)
uint8_t	parse_flags (wasm_code_ptr &code)
void	parse_table_type (wasm_code_ptr &code, table_type &tt)
void	parse_global_variable (wasm_code_ptr &code, global_variable &gv)
void	parse_memory_type (wasm_code_ptr &code, memory_type &mt)
void	parse_export_entry (wasm_code_ptr &code, export_entry &entry)
void	parse_func_type (wasm_code_ptr &code, func_type &ft)
void	parse_elem_segment (wasm_code_ptr &code, elem_segment &es)
void	parse_init_expr (wasm_code_ptr &code, init_expr &ie, uint8_t type)
void	parse_function_body (wasm_code_ptr &code, function_body &fb, std::size_t idx)
void	parse_function_body_code (wasm_code_ptr &code, size_t bounds, const detail::max_func_local_bytes_stack_checker< Options > &local_bytes_checker, Writer &code_writer, const func_type &ft, const local_types_t &local_types)
void	parse_data_segment (wasm_code_ptr &code, data_segment &ds)
template<typename Elem , typename ParseFunc >
void	parse_section_impl (wasm_code_ptr &code, vec< Elem > &elems, std::uint32_t max_elements, ParseFunc &&elem_parse)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::type_section, func_type > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::import_section, import_entry > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::function_section, uint32_t > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::table_section, table_type > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::memory_section, memory_type > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::global_section, global_variable > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::export_section, export_entry > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, typename std::enable_if_t< id==section_id::start_section, uint32_t > &start)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::element_section, elem_segment > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::code_section, function_body > > &elems)
template<uint8_t id>
void	parse_section (wasm_code_ptr &code, vec< typename std::enable_if_t< id==section_id::data_section, data_segment > > &elems)
template<size_t N>
varint< N >	parse_varint (const wasm_code &code, size_t index)
template<size_t N>
varuint< N >	parse_varuint (const wasm_code &code, size_t index)
void	on_mutable_global (uint8_t type)
void	validate_exports () const
template<typename T >
using	vec

Static Public Member Functions
static uint8_t	parse_varuint1 (wasm_code_ptr &code)
static uint8_t	parse_varuint7 (wasm_code_ptr &code)
static uint32_t	parse_varuint32 (wasm_code_ptr &code)
static int8_t	parse_varint7 (wasm_code_ptr &code)
static int32_t	parse_varint32 (wasm_code_ptr &code)
static int64_t	parse_varint64 (wasm_code_ptr &code)
static uint8_t	parse_varuint1 (wasm_code_ptr &code)
static uint8_t	parse_varuint7 (wasm_code_ptr &code)
static uint32_t	parse_varuint32 (wasm_code_ptr &code)
static int8_t	parse_varint7 (wasm_code_ptr &code)
static int32_t	parse_varint32 (wasm_code_ptr &code)
static int64_t	parse_varint64 (wasm_code_ptr &code)

Static Public Attributes
static constexpr uint8_t	any_type = 0x82

Detailed Description

template<typename Writer, typename Options = default_options, typename DebugInfo = null_debug_info>
class sysio::vm::binary_parser< Writer, Options, DebugInfo >

Definition at line 202 of file parser.hpp.

Member Typedef Documentation

branch_t

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

decltype(std::declval< Writer >().emit_if()) typedef sysio::vm::binary_parser< Writer, Options, DebugInfo >::branch_t = decltype(std::declval<Writer>().emit_if())

Definition at line 614 of file parser.hpp.

label_t

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

decltype(std::declval< Writer >().emit_end()) typedef sysio::vm::binary_parser< Writer, Options, DebugInfo >::label_t = decltype(std::declval<Writer>().emit_end())

Definition at line 613 of file parser.hpp.

vec

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<typename T >

using sysio::vm::binary_parser< Writer, Options, DebugInfo >::vec = guarded_vector<T>

Definition at line 207 of file parser.hpp.

Constructor & Destructor Documentation

binary_parser() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

sysio::vm::binary_parser< Writer, Options, DebugInfo >::binary_parser ( growable_allocator & alloc, const Options & options = Options{} )

inlineexplicit

Definition at line 204 of file parser.hpp.

{}) : _allocator(alloc), _options(options) {}

binary_parser() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

sysio::vm::binary_parser< Writer, Options, DebugInfo >::binary_parser ( growable_allocator & alloc, const Options & options = Options{} )

inlineexplicit

Definition at line 204 of file parser.hpp.

{}) : _allocator(alloc), _options(options) {}

Member Function Documentation

on_mutable_global() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::on_mutable_global ( uint8_t type )

inline

Definition at line 1352 of file parser.hpp.

                                           {
         _globals_checker.on_mutable_global(_options, type);
      }

on_mutable_global() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::on_mutable_global ( uint8_t type )

inline

Definition at line 1352 of file parser.hpp.

                                           {
         _globals_checker.on_mutable_global(_options, type);
      }

parse_custom() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_custom ( wasm_code_ptr & code )

inline

Definition at line 363 of file parser.hpp.

                                                    {
         auto section_name = parse_utf8_string(code, 0xFFFFFFFFu); // ignored, but needs to be validated
         if(detail::get_parse_custom_section_name(_options) &&
            section_name.size() == 4 && std::memcmp(section_name.raw(), "name", 4) == 0) {
            parse_name_section(code);
         } else {
            // skip to the end of the section
            code += code.bounds() - code.offset();
         }
      }

parse_custom() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_custom ( wasm_code_ptr & code )

inline

Definition at line 363 of file parser.hpp.

                                                    {
         auto section_name = parse_utf8_string(code, 0xFFFFFFFFu); // ignored, but needs to be validated
         if(detail::get_parse_custom_section_name(_options) &&
            section_name.size() == 4 && std::memcmp(section_name.raw(), "name", 4) == 0) {
            parse_name_section(code);
         } else {
            // skip to the end of the section
            code += code.bounds() - code.offset();
         }
      }

parse_data_segment() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_data_segment ( wasm_code_ptr & code, data_segment & ds )

inline

Definition at line 1229 of file parser.hpp.

                                                                     {
         SYS_VM_ASSERT(_mod->memories.size() != 0, wasm_parse_exception, "data requires memory");
         ds.index = parse_varuint32(code);
         parse_init_expr(code, ds.offset, types::i32);
         auto len =  parse_varuint32(code);
         SYS_VM_ASSERT(len <= detail::get_max_data_segment_bytes(_options), wasm_parse_exception, "data segment too large.");
         SYS_VM_ASSERT(static_cast<uint64_t>(static_cast<uint32_t>(ds.offset.value.i32)) + len <= detail::get_max_linear_memory_init(_options),
                       wasm_parse_exception, "out-of-bounds data section");
         auto guard = code.scoped_shrink_bounds(len);
         ds.data = decltype(ds.data){ _allocator, len};
         ds.data.copy(code.raw(), len);
         code += len;
      }

parse_data_segment() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_data_segment ( wasm_code_ptr & code, data_segment & ds )

inline

Definition at line 1229 of file parser.hpp.

                                                                     {
         SYS_VM_ASSERT(_mod->memories.size() != 0, wasm_parse_exception, "data requires memory");
         ds.index = parse_varuint32(code);
         parse_init_expr(code, ds.offset, types::i32);
         auto len =  parse_varuint32(code);
         SYS_VM_ASSERT(len <= detail::get_max_data_segment_bytes(_options), wasm_parse_exception, "data segment too large.");
         SYS_VM_ASSERT(static_cast<uint64_t>(static_cast<uint32_t>(ds.offset.value.i32)) + len <= detail::get_max_linear_memory_init(_options),
                       wasm_parse_exception, "out-of-bounds data section");
         auto guard = code.scoped_shrink_bounds(len);
         ds.data = decltype(ds.data){ _allocator, len};
         ds.data.copy(code.raw(), len);
         code += len;
      }

parse_elem_segment() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_elem_segment ( wasm_code_ptr & code, elem_segment & es )

inline

Definition at line 521 of file parser.hpp.

                                                                     {
         table_type* tt = nullptr;
         for (std::size_t i = 0; i < _mod->tables.size(); i++) {
            if (_mod->tables[i].element_type == types::anyfunc)
               tt = &(_mod->tables[i]);
         }
         SYS_VM_ASSERT(tt != nullptr, wasm_parse_exception, "table not declared");
         es.index = parse_varuint32(code);
         SYS_VM_ASSERT(es.index == 0, wasm_parse_exception, "only table index of 0 is supported");
         parse_init_expr(code, es.offset, types::i32);
         uint32_t           size  = parse_varuint32(code);
         SYS_VM_ASSERT(size <= detail::get_max_element_segment_elements(_options), wasm_parse_exception, "elem segment too large");
         decltype(es.elems) elems = { _allocator, size };
         for (uint32_t i = 0; i < size; i++) {
            uint32_t index                     = parse_varuint32(code);
            elems.at(i)                        = index;
            SYS_VM_ASSERT(index < _mod->get_functions_total(), wasm_parse_exception,  "elem for undefined function");
         }
         uint32_t offset = static_cast<uint32_t>(es.offset.value.i32);
         if ( static_cast<uint64_t>(size) + offset <= tt->table.size() ) {
            std::memcpy(tt->table.raw() + offset, elems.raw(), size * sizeof(uint32_t));
         } else {
            _mod->error = "elem out of range";
         }
         es.elems = std::move(elems);
      }

parse_elem_segment() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_elem_segment ( wasm_code_ptr & code, elem_segment & es )

inline

Definition at line 521 of file parser.hpp.

                                                                     {
         table_type* tt = nullptr;
         for (std::size_t i = 0; i < _mod->tables.size(); i++) {
            if (_mod->tables[i].element_type == types::anyfunc)
               tt = &(_mod->tables[i]);
         }
         SYS_VM_ASSERT(tt != nullptr, wasm_parse_exception, "table not declared");
         es.index = parse_varuint32(code);
         SYS_VM_ASSERT(es.index == 0, wasm_parse_exception, "only table index of 0 is supported");
         parse_init_expr(code, es.offset, types::i32);
         uint32_t           size  = parse_varuint32(code);
         SYS_VM_ASSERT(size <= detail::get_max_element_segment_elements(_options), wasm_parse_exception, "elem segment too large");
         decltype(es.elems) elems = { _allocator, size };
         for (uint32_t i = 0; i < size; i++) {
            uint32_t index                     = parse_varuint32(code);
            elems.at(i)                        = index;
            SYS_VM_ASSERT(index < _mod->get_functions_total(), wasm_parse_exception,  "elem for undefined function");
         }
         uint32_t offset = static_cast<uint32_t>(es.offset.value.i32);
         if ( static_cast<uint64_t>(size) + offset <= tt->table.size() ) {
            std::memcpy(tt->table.raw() + offset, elems.raw(), size * sizeof(uint32_t));
         } else {
            _mod->error = "elem out of range";
         }
         es.elems = std::move(elems);
      }

parse_export_entry() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_export_entry ( wasm_code_ptr & code, export_entry & entry )

inline

Definition at line 483 of file parser.hpp.

                                                                        {
         entry.field_str = parse_utf8_string(code, detail::get_max_symbol_bytes(_options));
         entry.kind  = (external_kind)(*code++);
         entry.index = parse_varuint32(code);
         switch(entry.kind) {
            case external_kind::Function: SYS_VM_ASSERT(entry.index < _mod->get_functions_total(), wasm_parse_exception, "function export out of range"); break;
            case external_kind::Table: SYS_VM_ASSERT(entry.index < _mod->tables.size(), wasm_parse_exception, "table export out of range"); break;
            case external_kind::Memory: SYS_VM_ASSERT(entry.index < _mod->memories.size(), wasm_parse_exception, "memory export out of range"); break;
            case external_kind::Global:
               SYS_VM_ASSERT(entry.index < _mod->globals.size(), wasm_parse_exception, "global export out of range");
               SYS_VM_ASSERT(!detail::get_forbid_export_mutable_globals(_options) || !_mod->globals.at(entry.index).type.mutability,
                             wasm_parse_exception, "cannot export mutable globals");
               break;
            default: SYS_VM_ASSERT(false, wasm_parse_exception, "Unknown export kind"); break;
         }
      }

parse_export_entry() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_export_entry ( wasm_code_ptr & code, export_entry & entry )

inline

Definition at line 483 of file parser.hpp.

                                                                        {
         entry.field_str = parse_utf8_string(code, detail::get_max_symbol_bytes(_options));
         entry.kind  = (external_kind)(*code++);
         entry.index = parse_varuint32(code);
         switch(entry.kind) {
            case external_kind::Function: SYS_VM_ASSERT(entry.index < _mod->get_functions_total(), wasm_parse_exception, "function export out of range"); break;
            case external_kind::Table: SYS_VM_ASSERT(entry.index < _mod->tables.size(), wasm_parse_exception, "table export out of range"); break;
            case external_kind::Memory: SYS_VM_ASSERT(entry.index < _mod->memories.size(), wasm_parse_exception, "memory export out of range"); break;
            case external_kind::Global:
               SYS_VM_ASSERT(entry.index < _mod->globals.size(), wasm_parse_exception, "global export out of range");
               SYS_VM_ASSERT(!detail::get_forbid_export_mutable_globals(_options) || !_mod->globals.at(entry.index).type.mutability,
                             wasm_parse_exception, "cannot export mutable globals");
               break;
            default: SYS_VM_ASSERT(false, wasm_parse_exception, "Unknown export kind"); break;
         }
      }

parse_flags() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_flags ( wasm_code_ptr & code )

inline

Definition at line 433 of file parser.hpp.

                                               {
         if (detail::get_allow_u32_limits_flags(_options)) {
            return parse_varuint32(code) & 0x1;
         } else {
            SYS_VM_ASSERT(*code == 0x0 || *code == 0x1, wasm_parse_exception, "invalid flags");
            return *code++;
         }
      }

parse_flags() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_flags ( wasm_code_ptr & code )

inline

Definition at line 433 of file parser.hpp.

                                               {
         if (detail::get_allow_u32_limits_flags(_options)) {
            return parse_varuint32(code) & 0x1;
         } else {
            SYS_VM_ASSERT(*code == 0x0 || *code == 0x1, wasm_parse_exception, "invalid flags");
            return *code++;
         }
      }

parse_func_type() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_func_type ( wasm_code_ptr & code, func_type & ft )

inline

Definition at line 500 of file parser.hpp.

                                                               {
         ft.form                              = *code++;
         SYS_VM_ASSERT(ft.form == 0x60, wasm_parse_exception, "invalid function type");
         decltype(ft.param_types) param_types = { _allocator, parse_varuint32(code) };
         for (size_t i = 0; i < param_types.size(); i++) {
            uint8_t pt        = *code++;
            param_types.at(i) = pt;
            SYS_VM_ASSERT(pt == types::i32 || pt == types::i64 || pt == types::f32 || pt == types::f64,
                          wasm_parse_exception, "invalid function param type");
         }
         ft.param_types  = std::move(param_types);
         ft.return_count = *code++;
         SYS_VM_ASSERT(ft.return_count < 2, wasm_parse_exception, "invalid function return count");
         if (ft.return_count > 0) {
            uint8_t rt        = *code++;
            ft.return_type = rt;
            SYS_VM_ASSERT(rt == types::i32 || rt == types::i64 || rt == types::f32 || rt == types::f64,
                          wasm_parse_exception, "invalid function return type");
         }
      }

parse_func_type() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_func_type ( wasm_code_ptr & code, func_type & ft )

inline

Definition at line 500 of file parser.hpp.

                                                               {
         ft.form                              = *code++;
         SYS_VM_ASSERT(ft.form == 0x60, wasm_parse_exception, "invalid function type");
         decltype(ft.param_types) param_types = { _allocator, parse_varuint32(code) };
         for (size_t i = 0; i < param_types.size(); i++) {
            uint8_t pt        = *code++;
            param_types.at(i) = pt;
            SYS_VM_ASSERT(pt == types::i32 || pt == types::i64 || pt == types::f32 || pt == types::f64,
                          wasm_parse_exception, "invalid function param type");
         }
         ft.param_types  = std::move(param_types);
         ft.return_count = *code++;
         SYS_VM_ASSERT(ft.return_count < 2, wasm_parse_exception, "invalid function return count");
         if (ft.return_count > 0) {
            uint8_t rt        = *code++;
            ft.return_type = rt;
            SYS_VM_ASSERT(rt == types::i32 || rt == types::i64 || rt == types::f32 || rt == types::f64,
                          wasm_parse_exception, "invalid function return type");
         }
      }

parse_function_body() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_function_body ( wasm_code_ptr & code, function_body & fb, std::size_t idx )

inline

Definition at line 574 of file parser.hpp.

                                                                                      {
         fb.size   = parse_varuint32(code);
         SYS_VM_ASSERT(fb.size <= detail::get_max_code_bytes(_options), wasm_parse_exception, "Function body too large");
         const auto&         before    = code.offset();
         const auto&         local_cnt = parse_varuint32(code);
         _current_function_index++;
         SYS_VM_ASSERT(local_cnt <= detail::get_max_local_sets(_options), wasm_parse_exception, "Number of local sets exceeds limit");
         decltype(fb.locals) locals    = { _allocator, local_cnt };
         func_type& ft = _mod->types.at(_mod->functions.at(idx));
         detail::max_func_local_bytes_checker<Options> local_checker(_options, ft);
         // parse the local entries
         for (size_t i = 0; i < local_cnt; i++) {
            auto count = parse_varuint32(code);
            auto type = *code++;
            if (detail::get_allow_invalid_empty_local_set(_options) && count == 0) type = types::i32;
            SYS_VM_ASSERT(type == types::i32 || type == types::i64 || type == types::f32 || type == types::f64,
                          wasm_parse_exception, "invalid local type");
            local_checker.on_local(_options, type, count);
            locals.at(i).count = count;
            locals.at(i).type  = type;
         }
         fb.locals = std::move(locals);
 
         fb.size -= code.offset() - before;
         auto guard = code.scoped_shrink_bounds(fb.size);
         _function_bodies.emplace_back(wasm_code_ptr{code.raw(), fb.size}, local_checker);
 
         code += fb.size-1;
         SYS_VM_ASSERT(detail::get_allow_code_after_function_end(_options) || *code == 0x0B,
                       wasm_parse_exception, "failed parsing function body, expected 'end'");
         ++code;
      }

Here is the call graph for this function:

parse_function_body() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_function_body ( wasm_code_ptr & code, function_body & fb, std::size_t idx )

inline

Definition at line 574 of file parser.hpp.

                                                                                      {
         fb.size   = parse_varuint32(code);
         SYS_VM_ASSERT(fb.size <= detail::get_max_code_bytes(_options), wasm_parse_exception, "Function body too large");
         const auto&         before    = code.offset();
         const auto&         local_cnt = parse_varuint32(code);
         _current_function_index++;
         SYS_VM_ASSERT(local_cnt <= detail::get_max_local_sets(_options), wasm_parse_exception, "Number of local sets exceeds limit");
         decltype(fb.locals) locals    = { _allocator, local_cnt };
         func_type& ft = _mod->types.at(_mod->functions.at(idx));
         detail::max_func_local_bytes_checker<Options> local_checker(_options, ft);
         // parse the local entries
         for (size_t i = 0; i < local_cnt; i++) {
            auto count = parse_varuint32(code);
            auto type = *code++;
            if (detail::get_allow_invalid_empty_local_set(_options) && count == 0) type = types::i32;
            SYS_VM_ASSERT(type == types::i32 || type == types::i64 || type == types::f32 || type == types::f64,
                          wasm_parse_exception, "invalid local type");
            local_checker.on_local(_options, type, count);
            locals.at(i).count = count;
            locals.at(i).type  = type;
         }
         fb.locals = std::move(locals);
 
         fb.size -= code.offset() - before;
         auto guard = code.scoped_shrink_bounds(fb.size);
         _function_bodies.emplace_back(wasm_code_ptr{code.raw(), fb.size}, local_checker);
 
         code += fb.size-1;
         SYS_VM_ASSERT(detail::get_allow_code_after_function_end(_options) || *code == 0x0B,
                       wasm_parse_exception, "failed parsing function body, expected 'end'");
         ++code;
      }

Here is the call graph for this function:

parse_function_body_code() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_function_body_code ( wasm_code_ptr & code, size_t bounds, const detail::max_func_local_bytes_stack_checker< Options > & local_bytes_checker, Writer & code_writer, const func_type & ft, const local_types_t & local_types )

inline

Definition at line 734 of file parser.hpp.

                                                                                                                {
 
         // Initialize the control stack with the current function as the sole element
         operand_stack_type_tracker op_stack{local_bytes_checker, _options};
         std::vector<pc_element_t> pc_stack{{
               op_stack.depth(),
               ft.return_count ? ft.return_type : static_cast<uint32_t>(types::pseudo),
               ft.return_count ? ft.return_type : static_cast<uint32_t>(types::pseudo),
               false,
               std::vector<branch_t>{}}};
 
         // writes the continuation of a label to address.  If the continuation
         // is not yet available, address will be recorded in the relocations
         // list for label.
         auto handle_branch_target = [&](uint32_t label, branch_t address) {
            SYS_VM_ASSERT(label < pc_stack.size(), wasm_parse_exception, "invalid label");
            pc_element_t& branch_target = pc_stack[pc_stack.size() - label - 1];
            std::visit(overloaded{ [&](label_t target) { code_writer.fix_branch(address, target); },
                                   [&](std::vector<branch_t>& relocations) { relocations.push_back(address); } },
               branch_target.relocations);
         };
 
         // Returns the number of operands that need to be popped when
         // branching to label.  If the label has a return value it will
         // be counted in this, and the high bit will be set to signal
         // its presence.
         auto compute_depth_change = [&](uint32_t label) -> uint32_t {
            SYS_VM_ASSERT(label < pc_stack.size(), wasm_parse_exception, "invalid label");
            pc_element_t& branch_target = pc_stack[pc_stack.size() - label - 1];
            uint32_t result = op_stack.depth() - branch_target.operand_depth;
            if(branch_target.label_result != types::pseudo) {
               // FIXME: Reusing the high bit imposes an additional constraint
               // on the maximum depth of the operand stack.  This isn't an
               // actual problem right now, because the stack is hard-coded
               // to 8192 elements, but it would be better to avoid spreading
               // this assumption around the code.
               result |= 0x80000000;
               op_stack.top(branch_target.label_result);
            }
            return result;
         };
 
         // Handles branches to the end of the scope and pops the pc_stack
         auto exit_scope = [&]() {
            // There must be at least one element
            SYS_VM_ASSERT(pc_stack.size(), wasm_parse_exception, "unexpected end instruction");
            // an if with an empty else cannot have a return value
            SYS_VM_ASSERT(!pc_stack.back().is_if || pc_stack.back().expected_result == types::pseudo, wasm_parse_exception, "wrong type");
            auto end_pos = code_writer.emit_end();
            if(auto* relocations = std::get_if<std::vector<branch_t>>(&pc_stack.back().relocations)) {
               for(auto branch_op : *relocations) {
                  code_writer.fix_branch(branch_op, end_pos);
               }
            }
            op_stack.pop_scope(pc_stack.back().expected_result);
            pc_stack.pop_back();
         };
 
         auto check_in_bounds = [&]{
            SYS_VM_ASSERT(!detail::get_allow_code_after_function_end(_options) || !pc_stack.empty(),
                          wasm_parse_exception, "code after function end");
         };
 
         while (code.offset() < bounds) {
            SYS_VM_ASSERT(pc_stack.size() <= detail::get_max_nested_structures(_options), wasm_parse_exception,
                          "nested structures validation failure");
 
            imap.on_instr_start(code_writer.get_addr(), code.raw());
 
            switch (*code++) {
               case opcodes::unreachable: check_in_bounds(); code_writer.emit_unreachable(); op_stack.start_unreachable(); break;
               case opcodes::nop: code_writer.emit_nop(); break;
               case opcodes::end: {
                  check_in_bounds();
                  exit_scope();
                  SYS_VM_ASSERT(detail::get_allow_code_after_function_end(_options) ||
                                !pc_stack.empty() || code.offset() == bounds, wasm_parse_exception, "function too short");
                  _nested_checker.on_end(_options);
                  break;
               }
               case opcodes::return_: {
                  check_in_bounds();
                  uint32_t label = pc_stack.size() - 1;
                  auto branch = code_writer.emit_return(compute_depth_change(label));
                  handle_branch_target(label, branch);
                  op_stack.start_unreachable();
               } break;
               case opcodes::block: {
                  uint32_t expected_result = *code++;
                  if(detail::get_allow_zero_blocktype(_options) && expected_result == 0)
                     expected_result = types::pseudo;
                  SYS_VM_ASSERT(expected_result == types::i32 || expected_result == types::i64 ||
                                expected_result == types::f32 || expected_result == types::f64 ||
                                expected_result == types::pseudo, wasm_parse_exception,
                                "Invalid type code in block");
                  pc_stack.push_back({op_stack.depth(), expected_result, expected_result, false, std::vector<branch_t>{}});
                  code_writer.emit_block();
                  op_stack.push_scope();
                  _nested_checker.on_control(_options);
               } break;
               case opcodes::loop: {
                  uint32_t expected_result = *code++;
                  if(detail::get_allow_zero_blocktype(_options) && expected_result == 0)
                     expected_result = types::pseudo;
                  SYS_VM_ASSERT(expected_result == types::i32 || expected_result == types::i64 ||
                                expected_result == types::f32 || expected_result == types::f64 ||
                                expected_result == types::pseudo, wasm_parse_exception,
                                "Invalid type code in loop");
                  auto pos = code_writer.emit_loop();
                  pc_stack.push_back({op_stack.depth(), expected_result, types::pseudo, false, pos});
                  op_stack.push_scope();
                  _nested_checker.on_control(_options);
               } break;
               case opcodes::if_: {
                  check_in_bounds();
                  uint32_t expected_result = *code++;
                  if(detail::get_allow_zero_blocktype(_options) && expected_result == 0)
                     expected_result = types::pseudo;
                  SYS_VM_ASSERT(expected_result == types::i32 || expected_result == types::i64 ||
                                expected_result == types::f32 || expected_result == types::f64 ||
                                expected_result == types::pseudo, wasm_parse_exception,
                                "Invalid type code in if");
                  auto branch = code_writer.emit_if();
                  op_stack.pop(types::i32);
                  pc_stack.push_back({op_stack.depth(), expected_result, expected_result, true, std::vector{branch}});
                  op_stack.push_scope();
                  _nested_checker.on_control(_options);
               } break;
               case opcodes::else_: {
                  check_in_bounds();
                  auto& old_index = pc_stack.back();
                  SYS_VM_ASSERT(old_index.is_if, wasm_parse_exception, "else outside if");
                  auto& relocations = std::get<std::vector<branch_t>>(old_index.relocations);
                  // reset the operand stack to the same state as the if
                  op_stack.pop(old_index.expected_result);
                  op_stack.pop_scope();
                  op_stack.push_scope();
                  // Overwrite the branch from the `if` with the `else`.
                  // We're left with a normal relocation list where everything
                  // branches to the corresponding `end`
                  relocations[0] = code_writer.emit_else(relocations[0]);
                  old_index.is_if = false;
                  _nested_checker.on_control(_options);
                  break;
               }
               case opcodes::br: {
                  check_in_bounds();
                  uint32_t label = parse_varuint32(code);
                  auto branch = code_writer.emit_br(compute_depth_change(label));
                  handle_branch_target(label, branch);
                  op_stack.start_unreachable();
               } break;
               case opcodes::br_if: {
                  check_in_bounds();
                  uint32_t label = parse_varuint32(code);
                  op_stack.pop(types::i32);
                  auto branch = code_writer.emit_br_if(compute_depth_change(label));
                  handle_branch_target(label, branch);
               } break;
               case opcodes::br_table: {
                  check_in_bounds();
                  size_t table_size = parse_varuint32(code);
                  SYS_VM_ASSERT(table_size <= detail::get_max_br_table_elements(_options), wasm_parse_exception, "Too many labels in br_table");
                  uint8_t result_type = 0;
                  op_stack.pop(types::i32);
                  auto handler = code_writer.emit_br_table(table_size);
                  for (size_t i = 0; i < table_size; i++) {
                     uint32_t label = parse_varuint32(code);
                     auto branch = handler.emit_case(compute_depth_change(label));
                     handle_branch_target(label, branch);
                     uint8_t one_result = pc_stack[pc_stack.size() - label - 1].label_result;
                     if(i == 0) {
                        result_type = one_result;
                     } else {
                        SYS_VM_ASSERT(result_type == one_result, wasm_parse_exception, "br_table labels must have the same type");
                     }
                  }
                  uint32_t label = parse_varuint32(code);
                  auto branch = handler.emit_default(compute_depth_change(label));
                  handle_branch_target(label, branch);
                  SYS_VM_ASSERT(table_size == 0 || result_type == pc_stack[pc_stack.size() - label - 1].label_result,
                                wasm_parse_exception, "br_table labels must have the same type");
                  op_stack.start_unreachable();
               } break;
               case opcodes::call: {
                  check_in_bounds();
                  uint32_t funcnum = parse_varuint32(code);
                  const func_type& ft = _mod->get_function_type(funcnum);
                  for(uint32_t i = 0; i < ft.param_types.size(); ++i)
                     op_stack.pop(ft.param_types[ft.param_types.size() - i - 1]);
                  SYS_VM_ASSERT(ft.return_count <= 1, wasm_parse_exception, "unsupported");
                  if(ft.return_count)
                     op_stack.push(ft.return_type);
                  code_writer.emit_call(ft, funcnum);
               } break;
               case opcodes::call_indirect: {
                  check_in_bounds();
                  uint32_t functypeidx = parse_varuint32(code);
                  const func_type& ft = _mod->types.at(functypeidx);
                  SYS_VM_ASSERT(_mod->tables.size() > 0, wasm_parse_exception, "call_indirect requires a table");
                  op_stack.pop(types::i32);
                  for(uint32_t i = 0; i < ft.param_types.size(); ++i)
                     op_stack.pop(ft.param_types[ft.param_types.size() - i - 1]);
                  SYS_VM_ASSERT(ft.return_count <= 1, wasm_parse_exception, "unsupported");
                  if(ft.return_count)
                     op_stack.push(ft.return_type);
                  code_writer.emit_call_indirect(ft, functypeidx);
                  SYS_VM_ASSERT(*code == 0, wasm_parse_exception, "call_indirect must end with 0x00.");
                  code++; // 0x00
                  break;
               }
               case opcodes::drop: check_in_bounds(); code_writer.emit_drop(); op_stack.pop(); break;
               case opcodes::select: {
                  check_in_bounds();
                  code_writer.emit_select();
                  op_stack.pop(types::i32);
                  uint8_t t0 = op_stack.pop();
                  uint8_t t1 = op_stack.pop();
                  SYS_VM_ASSERT(t0 == t1 || t0 == any_type || t1 == any_type, wasm_parse_exception, "incorrect types for select");
                  op_stack.push(t0 != any_type? t0 : t1);
               } break;
               case opcodes::get_local: {
                  uint32_t local_idx = parse_varuint32(code);
                  op_stack.push(local_types[local_idx]);
                  code_writer.emit_get_local(local_idx);
               } break;
               case opcodes::set_local: {
                  check_in_bounds();
                  uint32_t local_idx = parse_varuint32(code);
                  op_stack.pop(local_types[local_idx]);
                  code_writer.emit_set_local(local_idx);
               } break;
               case opcodes::tee_local: {
                  check_in_bounds();
                  uint32_t local_idx = parse_varuint32(code);
                  op_stack.top(local_types[local_idx]);
                  code_writer.emit_tee_local(local_idx);
               } break;
               case opcodes::get_global: {
                  uint32_t global_idx = parse_varuint32(code);
                  op_stack.push(_mod->globals.at(global_idx).type.content_type);
                  code_writer.emit_get_global(global_idx);
               } break;
               case opcodes::set_global: {
                  check_in_bounds();
                  uint32_t global_idx = parse_varuint32(code);
                  SYS_VM_ASSERT(_mod->globals.at(global_idx).type.mutability, wasm_parse_exception, "cannot set const global");
                  op_stack.pop(_mod->globals.at(global_idx).type.content_type);
                  code_writer.emit_set_global(global_idx);
               } break;
#define LOAD_OP(op_name, max_align, type)                            \
               case opcodes::op_name: {                              \
                  check_in_bounds();                                 \
                  SYS_VM_ASSERT(_mod->memories.size() > 0, wasm_parse_exception, "load requires memory"); \
                  uint32_t alignment = parse_varuint32(code);        \
                  uint32_t offset = parse_varuint32(code);           \
                  SYS_VM_ASSERT(alignment <= uint32_t(max_align), wasm_parse_exception, "alignment cannot be greater than size."); \
                  SYS_VM_ASSERT(offset <= detail::get_max_memory_offset(_options), wasm_parse_exception, "load offset too large."); \
                  op_stack.pop(types::i32);                          \
                  op_stack.push(types::type);                        \
                  code_writer.emit_ ## op_name( alignment, offset ); \
               } break;
 
               LOAD_OP(i32_load, 2, i32)
               LOAD_OP(i64_load, 3, i64)
               LOAD_OP(f32_load, 2, f32)
               LOAD_OP(f64_load, 3, f64)
               LOAD_OP(i32_load8_s, 0, i32)
               LOAD_OP(i32_load16_s, 1, i32)
               LOAD_OP(i32_load8_u, 0, i32)
               LOAD_OP(i32_load16_u, 1, i32)
               LOAD_OP(i64_load8_s, 0, i64)
               LOAD_OP(i64_load16_s, 1, i64)
               LOAD_OP(i64_load32_s, 2, i64)
               LOAD_OP(i64_load8_u, 0, i64)
               LOAD_OP(i64_load16_u, 1, i64)
               LOAD_OP(i64_load32_u, 2, i64)
 
#undef LOAD_OP
 
#define STORE_OP(op_name, max_align, type)                           \
               case opcodes::op_name: {                              \
                  check_in_bounds();                                 \
                  SYS_VM_ASSERT(_mod->memories.size() > 0, wasm_parse_exception, "store requires memory"); \
                  uint32_t alignment = parse_varuint32(code);        \
                  uint32_t offset = parse_varuint32(code);           \
                  SYS_VM_ASSERT(alignment <= uint32_t(max_align), wasm_parse_exception, "alignment cannot be greater than size."); \
                  SYS_VM_ASSERT(offset <= detail::get_max_memory_offset(_options), wasm_parse_exception, "store offset too large."); \
                  op_stack.pop(types::type);                         \
                  op_stack.pop(types::i32);                          \
                  code_writer.emit_ ## op_name( alignment, offset ); \
               } break;
 
               STORE_OP(i32_store, 2, i32)
               STORE_OP(i64_store, 3, i64)
               STORE_OP(f32_store, 2, f32)
               STORE_OP(f64_store, 3, f64)
               STORE_OP(i32_store8, 0, i32)
               STORE_OP(i32_store16, 1, i32)
               STORE_OP(i64_store8, 0, i64)
               STORE_OP(i64_store16, 1, i64)
               STORE_OP(i64_store32, 2, i64)
 
#undef STORE_OP
 
               case opcodes::current_memory:
                  SYS_VM_ASSERT(_mod->memories.size() != 0, wasm_parse_exception, "memory.size requires memory");
                  op_stack.push(types::i32);
                  SYS_VM_ASSERT(*code == 0, wasm_parse_exception, "memory.size must end with 0x00");
                  code++;
                  code_writer.emit_current_memory();
                  break;
               case opcodes::grow_memory:
                  check_in_bounds();
                  SYS_VM_ASSERT(_mod->memories.size() != 0, wasm_parse_exception, "memory.grow requires memory");
                  op_stack.pop(types::i32);
                  op_stack.push(types::i32);
                  SYS_VM_ASSERT(*code == 0, wasm_parse_exception, "memory.grow must end with 0x00");
                  code++;
                  code_writer.emit_grow_memory();
                  break;
               case opcodes::i32_const: code_writer.emit_i32_const( parse_varint32(code) ); op_stack.push(types::i32); break;
               case opcodes::i64_const: code_writer.emit_i64_const( parse_varint64(code) ); op_stack.push(types::i64); break;
               case opcodes::f32_const: {
                  code_writer.emit_f32_const( parse_raw<float>(code) );
                  op_stack.push(types::f32);
               } break;
               case opcodes::f64_const: {
                  code_writer.emit_f64_const( parse_raw<double>(code) );
                  op_stack.push(types::f64);
               } break;
 
#define UNOP(opname) \
               case opcodes::opname: check_in_bounds(); code_writer.emit_ ## opname(); op_stack.pop(types::A); op_stack.push(types::R); break;
#define BINOP(opname) \
               case opcodes::opname: check_in_bounds(); code_writer.emit_ ## opname(); op_stack.pop(types::A); op_stack.pop(types::A); op_stack.push(types::R); break;
#define CASTOP(dst, opname, src)                                         \
               case opcodes::dst ## _ ## opname ## _ ## src: check_in_bounds(); code_writer.emit_ ## dst ## _ ## opname ## _ ## src(); op_stack.pop(types::src); op_stack.push(types::dst); break;
 
#define R i32
#define A i32
               UNOP(i32_eqz)
               BINOP(i32_eq)
               BINOP(i32_ne)
               BINOP(i32_lt_s)
               BINOP(i32_lt_u)
               BINOP(i32_gt_s)
               BINOP(i32_gt_u)
               BINOP(i32_le_s)
               BINOP(i32_le_u)
               BINOP(i32_ge_s)
               BINOP(i32_ge_u)
#undef A
#define A i64
               UNOP(i64_eqz)
               BINOP(i64_eq)
               BINOP(i64_ne)
               BINOP(i64_lt_s)
               BINOP(i64_lt_u)
               BINOP(i64_gt_s)
               BINOP(i64_gt_u)
               BINOP(i64_le_s)
               BINOP(i64_le_u)
               BINOP(i64_ge_s)
               BINOP(i64_ge_u)
#undef A
#define A f32
               BINOP(f32_eq)
               BINOP(f32_ne)
               BINOP(f32_lt)
               BINOP(f32_gt)
               BINOP(f32_le)
               BINOP(f32_ge)
#undef A
#define A f64
               BINOP(f64_eq)
               BINOP(f64_ne)
               BINOP(f64_lt)
               BINOP(f64_gt)
               BINOP(f64_le)
               BINOP(f64_ge)
#undef A
#undef R
#define R A
#define A i32
               UNOP(i32_clz)
               UNOP(i32_ctz)
               UNOP(i32_popcnt)
               BINOP(i32_add)
               BINOP(i32_sub)
               BINOP(i32_mul)
               BINOP(i32_div_s)
               BINOP(i32_div_u)
               BINOP(i32_rem_s)
               BINOP(i32_rem_u)
               BINOP(i32_and)
               BINOP(i32_or)
               BINOP(i32_xor)
               BINOP(i32_shl)
               BINOP(i32_shr_s)
               BINOP(i32_shr_u)
               BINOP(i32_rotl)
               BINOP(i32_rotr)
#undef A
#define A i64
               UNOP(i64_clz)
               UNOP(i64_ctz)
               UNOP(i64_popcnt)
               BINOP(i64_add)
               BINOP(i64_sub)
               BINOP(i64_mul)
               BINOP(i64_div_s)
               BINOP(i64_div_u)
               BINOP(i64_rem_s)
               BINOP(i64_rem_u)
               BINOP(i64_and)
               BINOP(i64_or)
               BINOP(i64_xor)
               BINOP(i64_shl)
               BINOP(i64_shr_s)
               BINOP(i64_shr_u)
               BINOP(i64_rotl)
               BINOP(i64_rotr)
#undef A
#define A f32
               UNOP(f32_abs)
               UNOP(f32_neg)
               UNOP(f32_ceil)
               UNOP(f32_floor)
               UNOP(f32_trunc)
               UNOP(f32_nearest)
               UNOP(f32_sqrt)
               BINOP(f32_add)
               BINOP(f32_sub)
               BINOP(f32_mul)
               BINOP(f32_div)
               BINOP(f32_min)
               BINOP(f32_max)
               BINOP(f32_copysign)
#undef A
#define A f64
               UNOP(f64_abs)
               UNOP(f64_neg)
               UNOP(f64_ceil)
               UNOP(f64_floor)
               UNOP(f64_trunc)
               UNOP(f64_nearest)
               UNOP(f64_sqrt)
               BINOP(f64_add)
               BINOP(f64_sub)
               BINOP(f64_mul)
               BINOP(f64_div)
               BINOP(f64_min)
               BINOP(f64_max)
               BINOP(f64_copysign)
#undef A
#undef R
 
               CASTOP(i32, wrap, i64)
               CASTOP(i32, trunc_s, f32)
               CASTOP(i32, trunc_u, f32)
               CASTOP(i32, trunc_s, f64)
               CASTOP(i32, trunc_u, f64)
               CASTOP(i64, extend_s, i32)
               CASTOP(i64, extend_u, i32)
               CASTOP(i64, trunc_s, f32)
               CASTOP(i64, trunc_u, f32)
               CASTOP(i64, trunc_s, f64)
               CASTOP(i64, trunc_u, f64)
               CASTOP(f32, convert_s, i32)
               CASTOP(f32, convert_u, i32)
               CASTOP(f32, convert_s, i64)
               CASTOP(f32, convert_u, i64)
               CASTOP(f32, demote, f64)
               CASTOP(f64, convert_s, i32)
               CASTOP(f64, convert_u, i32)
               CASTOP(f64, convert_s, i64)
               CASTOP(f64, convert_u, i64)
               CASTOP(f64, promote, f32)
               CASTOP(i32, reinterpret, f32)
               CASTOP(i64, reinterpret, f64)
               CASTOP(f32, reinterpret, i32)
               CASTOP(f64, reinterpret, i64)
 
#undef CASTOP
#undef UNOP
#undef BINOP
               default: SYS_VM_ASSERT(false, wasm_parse_exception, "Illegal instruction");
            }
         }
         SYS_VM_ASSERT( pc_stack.empty(), wasm_parse_exception, "function body too long" );
         _mod->maximum_stack = std::max(_mod->maximum_stack, static_cast<uint64_t>(op_stack.maximum_operand_depth) + local_types.locals_count());
      }

Here is the call graph for this function:

parse_function_body_code() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_function_body_code ( wasm_code_ptr & code, size_t bounds, const detail::max_func_local_bytes_stack_checker< Options > & local_bytes_checker, Writer & code_writer, const func_type & ft, const local_types_t & local_types )

inline

Definition at line 734 of file parser.hpp.

                                                                                                                {
 
         // Initialize the control stack with the current function as the sole element
         operand_stack_type_tracker op_stack{local_bytes_checker, _options};
         std::vector<pc_element_t> pc_stack{{
               op_stack.depth(),
               ft.return_count ? ft.return_type : static_cast<uint32_t>(types::pseudo),
               ft.return_count ? ft.return_type : static_cast<uint32_t>(types::pseudo),
               false,
               std::vector<branch_t>{}}};
 
         // writes the continuation of a label to address.  If the continuation
         // is not yet available, address will be recorded in the relocations
         // list for label.
         auto handle_branch_target = [&](uint32_t label, branch_t address) {
            SYS_VM_ASSERT(label < pc_stack.size(), wasm_parse_exception, "invalid label");
            pc_element_t& branch_target = pc_stack[pc_stack.size() - label - 1];
            std::visit(overloaded{ [&](label_t target) { code_writer.fix_branch(address, target); },
                                   [&](std::vector<branch_t>& relocations) { relocations.push_back(address); } },
               branch_target.relocations);
         };
 
         // Returns the number of operands that need to be popped when
         // branching to label.  If the label has a return value it will
         // be counted in this, and the high bit will be set to signal
         // its presence.
         auto compute_depth_change = [&](uint32_t label) -> uint32_t {
            SYS_VM_ASSERT(label < pc_stack.size(), wasm_parse_exception, "invalid label");
            pc_element_t& branch_target = pc_stack[pc_stack.size() - label - 1];
            uint32_t result = op_stack.depth() - branch_target.operand_depth;
            if(branch_target.label_result != types::pseudo) {
               // FIXME: Reusing the high bit imposes an additional constraint
               // on the maximum depth of the operand stack.  This isn't an
               // actual problem right now, because the stack is hard-coded
               // to 8192 elements, but it would be better to avoid spreading
               // this assumption around the code.
               result |= 0x80000000;
               op_stack.top(branch_target.label_result);
            }
            return result;
         };
 
         // Handles branches to the end of the scope and pops the pc_stack
         auto exit_scope = [&]() {
            // There must be at least one element
            SYS_VM_ASSERT(pc_stack.size(), wasm_parse_exception, "unexpected end instruction");
            // an if with an empty else cannot have a return value
            SYS_VM_ASSERT(!pc_stack.back().is_if || pc_stack.back().expected_result == types::pseudo, wasm_parse_exception, "wrong type");
            auto end_pos = code_writer.emit_end();
            if(auto* relocations = std::get_if<std::vector<branch_t>>(&pc_stack.back().relocations)) {
               for(auto branch_op : *relocations) {
                  code_writer.fix_branch(branch_op, end_pos);
               }
            }
            op_stack.pop_scope(pc_stack.back().expected_result);
            pc_stack.pop_back();
         };
 
         auto check_in_bounds = [&]{
            SYS_VM_ASSERT(!detail::get_allow_code_after_function_end(_options) || !pc_stack.empty(),
                          wasm_parse_exception, "code after function end");
         };
 
         while (code.offset() < bounds) {
            SYS_VM_ASSERT(pc_stack.size() <= detail::get_max_nested_structures(_options), wasm_parse_exception,
                          "nested structures validation failure");
 
            imap.on_instr_start(code_writer.get_addr(), code.raw());
 
            switch (*code++) {
               case opcodes::unreachable: check_in_bounds(); code_writer.emit_unreachable(); op_stack.start_unreachable(); break;
               case opcodes::nop: code_writer.emit_nop(); break;
               case opcodes::end: {
                  check_in_bounds();
                  exit_scope();
                  SYS_VM_ASSERT(detail::get_allow_code_after_function_end(_options) ||
                                !pc_stack.empty() || code.offset() == bounds, wasm_parse_exception, "function too short");
                  _nested_checker.on_end(_options);
                  break;
               }
               case opcodes::return_: {
                  check_in_bounds();
                  uint32_t label = pc_stack.size() - 1;
                  auto branch = code_writer.emit_return(compute_depth_change(label));
                  handle_branch_target(label, branch);
                  op_stack.start_unreachable();
               } break;
               case opcodes::block: {
                  uint32_t expected_result = *code++;
                  if(detail::get_allow_zero_blocktype(_options) && expected_result == 0)
                     expected_result = types::pseudo;
                  SYS_VM_ASSERT(expected_result == types::i32 || expected_result == types::i64 ||
                                expected_result == types::f32 || expected_result == types::f64 ||
                                expected_result == types::pseudo, wasm_parse_exception,
                                "Invalid type code in block");
                  pc_stack.push_back({op_stack.depth(), expected_result, expected_result, false, std::vector<branch_t>{}});
                  code_writer.emit_block();
                  op_stack.push_scope();
                  _nested_checker.on_control(_options);
               } break;
               case opcodes::loop: {
                  uint32_t expected_result = *code++;
                  if(detail::get_allow_zero_blocktype(_options) && expected_result == 0)
                     expected_result = types::pseudo;
                  SYS_VM_ASSERT(expected_result == types::i32 || expected_result == types::i64 ||
                                expected_result == types::f32 || expected_result == types::f64 ||
                                expected_result == types::pseudo, wasm_parse_exception,
                                "Invalid type code in loop");
                  auto pos = code_writer.emit_loop();
                  pc_stack.push_back({op_stack.depth(), expected_result, types::pseudo, false, pos});
                  op_stack.push_scope();
                  _nested_checker.on_control(_options);
               } break;
               case opcodes::if_: {
                  check_in_bounds();
                  uint32_t expected_result = *code++;
                  if(detail::get_allow_zero_blocktype(_options) && expected_result == 0)
                     expected_result = types::pseudo;
                  SYS_VM_ASSERT(expected_result == types::i32 || expected_result == types::i64 ||
                                expected_result == types::f32 || expected_result == types::f64 ||
                                expected_result == types::pseudo, wasm_parse_exception,
                                "Invalid type code in if");
                  auto branch = code_writer.emit_if();
                  op_stack.pop(types::i32);
                  pc_stack.push_back({op_stack.depth(), expected_result, expected_result, true, std::vector{branch}});
                  op_stack.push_scope();
                  _nested_checker.on_control(_options);
               } break;
               case opcodes::else_: {
                  check_in_bounds();
                  auto& old_index = pc_stack.back();
                  SYS_VM_ASSERT(old_index.is_if, wasm_parse_exception, "else outside if");
                  auto& relocations = std::get<std::vector<branch_t>>(old_index.relocations);
                  // reset the operand stack to the same state as the if
                  op_stack.pop(old_index.expected_result);
                  op_stack.pop_scope();
                  op_stack.push_scope();
                  // Overwrite the branch from the `if` with the `else`.
                  // We're left with a normal relocation list where everything
                  // branches to the corresponding `end`
                  relocations[0] = code_writer.emit_else(relocations[0]);
                  old_index.is_if = false;
                  _nested_checker.on_control(_options);
                  break;
               }
               case opcodes::br: {
                  check_in_bounds();
                  uint32_t label = parse_varuint32(code);
                  auto branch = code_writer.emit_br(compute_depth_change(label));
                  handle_branch_target(label, branch);
                  op_stack.start_unreachable();
               } break;
               case opcodes::br_if: {
                  check_in_bounds();
                  uint32_t label = parse_varuint32(code);
                  op_stack.pop(types::i32);
                  auto branch = code_writer.emit_br_if(compute_depth_change(label));
                  handle_branch_target(label, branch);
               } break;
               case opcodes::br_table: {
                  check_in_bounds();
                  size_t table_size = parse_varuint32(code);
                  SYS_VM_ASSERT(table_size <= detail::get_max_br_table_elements(_options), wasm_parse_exception, "Too many labels in br_table");
                  uint8_t result_type = 0;
                  op_stack.pop(types::i32);
                  auto handler = code_writer.emit_br_table(table_size);
                  for (size_t i = 0; i < table_size; i++) {
                     uint32_t label = parse_varuint32(code);
                     auto branch = handler.emit_case(compute_depth_change(label));
                     handle_branch_target(label, branch);
                     uint8_t one_result = pc_stack[pc_stack.size() - label - 1].label_result;
                     if(i == 0) {
                        result_type = one_result;
                     } else {
                        SYS_VM_ASSERT(result_type == one_result, wasm_parse_exception, "br_table labels must have the same type");
                     }
                  }
                  uint32_t label = parse_varuint32(code);
                  auto branch = handler.emit_default(compute_depth_change(label));
                  handle_branch_target(label, branch);
                  SYS_VM_ASSERT(table_size == 0 || result_type == pc_stack[pc_stack.size() - label - 1].label_result,
                                wasm_parse_exception, "br_table labels must have the same type");
                  op_stack.start_unreachable();
               } break;
               case opcodes::call: {
                  check_in_bounds();
                  uint32_t funcnum = parse_varuint32(code);
                  const func_type& ft = _mod->get_function_type(funcnum);
                  for(uint32_t i = 0; i < ft.param_types.size(); ++i)
                     op_stack.pop(ft.param_types[ft.param_types.size() - i - 1]);
                  SYS_VM_ASSERT(ft.return_count <= 1, wasm_parse_exception, "unsupported");
                  if(ft.return_count)
                     op_stack.push(ft.return_type);
                  code_writer.emit_call(ft, funcnum);
               } break;
               case opcodes::call_indirect: {
                  check_in_bounds();
                  uint32_t functypeidx = parse_varuint32(code);
                  const func_type& ft = _mod->types.at(functypeidx);
                  SYS_VM_ASSERT(_mod->tables.size() > 0, wasm_parse_exception, "call_indirect requires a table");
                  op_stack.pop(types::i32);
                  for(uint32_t i = 0; i < ft.param_types.size(); ++i)
                     op_stack.pop(ft.param_types[ft.param_types.size() - i - 1]);
                  SYS_VM_ASSERT(ft.return_count <= 1, wasm_parse_exception, "unsupported");
                  if(ft.return_count)
                     op_stack.push(ft.return_type);
                  code_writer.emit_call_indirect(ft, functypeidx);
                  SYS_VM_ASSERT(*code == 0, wasm_parse_exception, "call_indirect must end with 0x00.");
                  code++; // 0x00
                  break;
               }
               case opcodes::drop: check_in_bounds(); code_writer.emit_drop(); op_stack.pop(); break;
               case opcodes::select: {
                  check_in_bounds();
                  code_writer.emit_select();
                  op_stack.pop(types::i32);
                  uint8_t t0 = op_stack.pop();
                  uint8_t t1 = op_stack.pop();
                  SYS_VM_ASSERT(t0 == t1 || t0 == any_type || t1 == any_type, wasm_parse_exception, "incorrect types for select");
                  op_stack.push(t0 != any_type? t0 : t1);
               } break;
               case opcodes::get_local: {
                  uint32_t local_idx = parse_varuint32(code);
                  op_stack.push(local_types[local_idx]);
                  code_writer.emit_get_local(local_idx);
               } break;
               case opcodes::set_local: {
                  check_in_bounds();
                  uint32_t local_idx = parse_varuint32(code);
                  op_stack.pop(local_types[local_idx]);
                  code_writer.emit_set_local(local_idx);
               } break;
               case opcodes::tee_local: {
                  check_in_bounds();
                  uint32_t local_idx = parse_varuint32(code);
                  op_stack.top(local_types[local_idx]);
                  code_writer.emit_tee_local(local_idx);
               } break;
               case opcodes::get_global: {
                  uint32_t global_idx = parse_varuint32(code);
                  op_stack.push(_mod->globals.at(global_idx).type.content_type);
                  code_writer.emit_get_global(global_idx);
               } break;
               case opcodes::set_global: {
                  check_in_bounds();
                  uint32_t global_idx = parse_varuint32(code);
                  SYS_VM_ASSERT(_mod->globals.at(global_idx).type.mutability, wasm_parse_exception, "cannot set const global");
                  op_stack.pop(_mod->globals.at(global_idx).type.content_type);
                  code_writer.emit_set_global(global_idx);
               } break;
#define LOAD_OP(op_name, max_align, type)                            \
               case opcodes::op_name: {                              \
                  check_in_bounds();                                 \
                  SYS_VM_ASSERT(_mod->memories.size() > 0, wasm_parse_exception, "load requires memory"); \
                  uint32_t alignment = parse_varuint32(code);        \
                  uint32_t offset = parse_varuint32(code);           \
                  SYS_VM_ASSERT(alignment <= uint32_t(max_align), wasm_parse_exception, "alignment cannot be greater than size."); \
                  SYS_VM_ASSERT(offset <= detail::get_max_memory_offset(_options), wasm_parse_exception, "load offset too large."); \
                  op_stack.pop(types::i32);                          \
                  op_stack.push(types::type);                        \
                  code_writer.emit_ ## op_name( alignment, offset ); \
               } break;
 
               LOAD_OP(i32_load, 2, i32)
               LOAD_OP(i64_load, 3, i64)
               LOAD_OP(f32_load, 2, f32)
               LOAD_OP(f64_load, 3, f64)
               LOAD_OP(i32_load8_s, 0, i32)
               LOAD_OP(i32_load16_s, 1, i32)
               LOAD_OP(i32_load8_u, 0, i32)
               LOAD_OP(i32_load16_u, 1, i32)
               LOAD_OP(i64_load8_s, 0, i64)
               LOAD_OP(i64_load16_s, 1, i64)
               LOAD_OP(i64_load32_s, 2, i64)
               LOAD_OP(i64_load8_u, 0, i64)
               LOAD_OP(i64_load16_u, 1, i64)
               LOAD_OP(i64_load32_u, 2, i64)
 
#undef LOAD_OP
 
#define STORE_OP(op_name, max_align, type)                           \
               case opcodes::op_name: {                              \
                  check_in_bounds();                                 \
                  SYS_VM_ASSERT(_mod->memories.size() > 0, wasm_parse_exception, "store requires memory"); \
                  uint32_t alignment = parse_varuint32(code);        \
                  uint32_t offset = parse_varuint32(code);           \
                  SYS_VM_ASSERT(alignment <= uint32_t(max_align), wasm_parse_exception, "alignment cannot be greater than size."); \
                  SYS_VM_ASSERT(offset <= detail::get_max_memory_offset(_options), wasm_parse_exception, "store offset too large."); \
                  op_stack.pop(types::type);                         \
                  op_stack.pop(types::i32);                          \
                  code_writer.emit_ ## op_name( alignment, offset ); \
               } break;
 
               STORE_OP(i32_store, 2, i32)
               STORE_OP(i64_store, 3, i64)
               STORE_OP(f32_store, 2, f32)
               STORE_OP(f64_store, 3, f64)
               STORE_OP(i32_store8, 0, i32)
               STORE_OP(i32_store16, 1, i32)
               STORE_OP(i64_store8, 0, i64)
               STORE_OP(i64_store16, 1, i64)
               STORE_OP(i64_store32, 2, i64)
 
#undef STORE_OP
 
               case opcodes::current_memory:
                  SYS_VM_ASSERT(_mod->memories.size() != 0, wasm_parse_exception, "memory.size requires memory");
                  op_stack.push(types::i32);
                  SYS_VM_ASSERT(*code == 0, wasm_parse_exception, "memory.size must end with 0x00");
                  code++;
                  code_writer.emit_current_memory();
                  break;
               case opcodes::grow_memory:
                  check_in_bounds();
                  SYS_VM_ASSERT(_mod->memories.size() != 0, wasm_parse_exception, "memory.grow requires memory");
                  op_stack.pop(types::i32);
                  op_stack.push(types::i32);
                  SYS_VM_ASSERT(*code == 0, wasm_parse_exception, "memory.grow must end with 0x00");
                  code++;
                  code_writer.emit_grow_memory();
                  break;
               case opcodes::i32_const: code_writer.emit_i32_const( parse_varint32(code) ); op_stack.push(types::i32); break;
               case opcodes::i64_const: code_writer.emit_i64_const( parse_varint64(code) ); op_stack.push(types::i64); break;
               case opcodes::f32_const: {
                  code_writer.emit_f32_const( parse_raw<float>(code) );
                  op_stack.push(types::f32);
               } break;
               case opcodes::f64_const: {
                  code_writer.emit_f64_const( parse_raw<double>(code) );
                  op_stack.push(types::f64);
               } break;
 
#define UNOP(opname) \
               case opcodes::opname: check_in_bounds(); code_writer.emit_ ## opname(); op_stack.pop(types::A); op_stack.push(types::R); break;
#define BINOP(opname) \
               case opcodes::opname: check_in_bounds(); code_writer.emit_ ## opname(); op_stack.pop(types::A); op_stack.pop(types::A); op_stack.push(types::R); break;
#define CASTOP(dst, opname, src)                                         \
               case opcodes::dst ## _ ## opname ## _ ## src: check_in_bounds(); code_writer.emit_ ## dst ## _ ## opname ## _ ## src(); op_stack.pop(types::src); op_stack.push(types::dst); break;
 
#define R i32
#define A i32
               UNOP(i32_eqz)
               BINOP(i32_eq)
               BINOP(i32_ne)
               BINOP(i32_lt_s)
               BINOP(i32_lt_u)
               BINOP(i32_gt_s)
               BINOP(i32_gt_u)
               BINOP(i32_le_s)
               BINOP(i32_le_u)
               BINOP(i32_ge_s)
               BINOP(i32_ge_u)
#undef A
#define A i64
               UNOP(i64_eqz)
               BINOP(i64_eq)
               BINOP(i64_ne)
               BINOP(i64_lt_s)
               BINOP(i64_lt_u)
               BINOP(i64_gt_s)
               BINOP(i64_gt_u)
               BINOP(i64_le_s)
               BINOP(i64_le_u)
               BINOP(i64_ge_s)
               BINOP(i64_ge_u)
#undef A
#define A f32
               BINOP(f32_eq)
               BINOP(f32_ne)
               BINOP(f32_lt)
               BINOP(f32_gt)
               BINOP(f32_le)
               BINOP(f32_ge)
#undef A
#define A f64
               BINOP(f64_eq)
               BINOP(f64_ne)
               BINOP(f64_lt)
               BINOP(f64_gt)
               BINOP(f64_le)
               BINOP(f64_ge)
#undef A
#undef R
#define R A
#define A i32
               UNOP(i32_clz)
               UNOP(i32_ctz)
               UNOP(i32_popcnt)
               BINOP(i32_add)
               BINOP(i32_sub)
               BINOP(i32_mul)
               BINOP(i32_div_s)
               BINOP(i32_div_u)
               BINOP(i32_rem_s)
               BINOP(i32_rem_u)
               BINOP(i32_and)
               BINOP(i32_or)
               BINOP(i32_xor)
               BINOP(i32_shl)
               BINOP(i32_shr_s)
               BINOP(i32_shr_u)
               BINOP(i32_rotl)
               BINOP(i32_rotr)
#undef A
#define A i64
               UNOP(i64_clz)
               UNOP(i64_ctz)
               UNOP(i64_popcnt)
               BINOP(i64_add)
               BINOP(i64_sub)
               BINOP(i64_mul)
               BINOP(i64_div_s)
               BINOP(i64_div_u)
               BINOP(i64_rem_s)
               BINOP(i64_rem_u)
               BINOP(i64_and)
               BINOP(i64_or)
               BINOP(i64_xor)
               BINOP(i64_shl)
               BINOP(i64_shr_s)
               BINOP(i64_shr_u)
               BINOP(i64_rotl)
               BINOP(i64_rotr)
#undef A
#define A f32
               UNOP(f32_abs)
               UNOP(f32_neg)
               UNOP(f32_ceil)
               UNOP(f32_floor)
               UNOP(f32_trunc)
               UNOP(f32_nearest)
               UNOP(f32_sqrt)
               BINOP(f32_add)
               BINOP(f32_sub)
               BINOP(f32_mul)
               BINOP(f32_div)
               BINOP(f32_min)
               BINOP(f32_max)
               BINOP(f32_copysign)
#undef A
#define A f64
               UNOP(f64_abs)
               UNOP(f64_neg)
               UNOP(f64_ceil)
               UNOP(f64_floor)
               UNOP(f64_trunc)
               UNOP(f64_nearest)
               UNOP(f64_sqrt)
               BINOP(f64_add)
               BINOP(f64_sub)
               BINOP(f64_mul)
               BINOP(f64_div)
               BINOP(f64_min)
               BINOP(f64_max)
               BINOP(f64_copysign)
#undef A
#undef R
 
               CASTOP(i32, wrap, i64)
               CASTOP(i32, trunc_s, f32)
               CASTOP(i32, trunc_u, f32)
               CASTOP(i32, trunc_s, f64)
               CASTOP(i32, trunc_u, f64)
               CASTOP(i64, extend_s, i32)
               CASTOP(i64, extend_u, i32)
               CASTOP(i64, trunc_s, f32)
               CASTOP(i64, trunc_u, f32)
               CASTOP(i64, trunc_s, f64)
               CASTOP(i64, trunc_u, f64)
               CASTOP(f32, convert_s, i32)
               CASTOP(f32, convert_u, i32)
               CASTOP(f32, convert_s, i64)
               CASTOP(f32, convert_u, i64)
               CASTOP(f32, demote, f64)
               CASTOP(f64, convert_s, i32)
               CASTOP(f64, convert_u, i32)
               CASTOP(f64, convert_s, i64)
               CASTOP(f64, convert_u, i64)
               CASTOP(f64, promote, f32)
               CASTOP(i32, reinterpret, f32)
               CASTOP(i64, reinterpret, f64)
               CASTOP(f32, reinterpret, i32)
               CASTOP(f64, reinterpret, i64)
 
#undef CASTOP
#undef UNOP
#undef BINOP
               default: SYS_VM_ASSERT(false, wasm_parse_exception, "Illegal instruction");
            }
         }
         SYS_VM_ASSERT( pc_stack.empty(), wasm_parse_exception, "function body too long" );
         _mod->maximum_stack = std::max(_mod->maximum_stack, static_cast<uint64_t>(op_stack.maximum_operand_depth) + local_types.locals_count());
      }

Here is the call graph for this function:

parse_global_variable() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_global_variable ( wasm_code_ptr & code, global_variable & gv )

inline

Definition at line 456 of file parser.hpp.

                                                                           {
         uint8_t ct           = *code++;
         gv.type.content_type = ct;
         SYS_VM_ASSERT(ct == types::i32 || ct == types::i64 || ct == types::f32 || ct == types::f64,
                       wasm_parse_exception, "invalid global content type");
 
         gv.type.mutability = parse_varuint1(code);
         if(gv.type.mutability)
            on_mutable_global(ct);
         parse_init_expr(code, gv.init, ct);
         gv.current = gv.init;
      }

parse_global_variable() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_global_variable ( wasm_code_ptr & code, global_variable & gv )

inline

Definition at line 456 of file parser.hpp.

                                                                           {
         uint8_t ct           = *code++;
         gv.type.content_type = ct;
         SYS_VM_ASSERT(ct == types::i32 || ct == types::i64 || ct == types::f32 || ct == types::f64,
                       wasm_parse_exception, "invalid global content type");
 
         gv.type.mutability = parse_varuint1(code);
         if(gv.type.mutability)
            on_mutable_global(ct);
         parse_init_expr(code, gv.init, ct);
         gv.current = gv.init;
      }

parse_import_entry() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_import_entry ( wasm_code_ptr & code, import_entry & entry )

inline

Definition at line 419 of file parser.hpp.

                                                                        {
         entry.module_str = parse_utf8_string(code, detail::get_max_symbol_bytes(_options));
         entry.field_str = parse_utf8_string(code, detail::get_max_symbol_bytes(_options));
         entry.kind = (external_kind)(*code++);
         auto type  = parse_varuint32(code);
         switch ((uint8_t)entry.kind) {
            case external_kind::Function:
               entry.type.func_t = type;
               SYS_VM_ASSERT(type < _mod->types.size(), wasm_parse_exception, "Invalid function type");
               break;
            default: SYS_VM_ASSERT(false, wasm_unsupported_import_exception, "only function imports are supported");
         }
      }

parse_import_entry() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_import_entry ( wasm_code_ptr & code, import_entry & entry )

inline

Definition at line 419 of file parser.hpp.

                                                                        {
         entry.module_str = parse_utf8_string(code, detail::get_max_symbol_bytes(_options));
         entry.field_str = parse_utf8_string(code, detail::get_max_symbol_bytes(_options));
         entry.kind = (external_kind)(*code++);
         auto type  = parse_varuint32(code);
         switch ((uint8_t)entry.kind) {
            case external_kind::Function:
               entry.type.func_t = type;
               SYS_VM_ASSERT(type < _mod->types.size(), wasm_parse_exception, "Invalid function type");
               break;
            default: SYS_VM_ASSERT(false, wasm_unsupported_import_exception, "only function imports are supported");
         }
      }

parse_init_expr() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_init_expr ( wasm_code_ptr & code, init_expr & ie, uint8_t type )

inline

Definition at line 548 of file parser.hpp.

                                                                             {
         ie.opcode = *code++;
         switch (ie.opcode) {
            case opcodes::i32_const:
               ie.value.i32 = parse_varint32(code);
               SYS_VM_ASSERT(type == types::i32, wasm_parse_exception, "expected i32 initializer");
               break;
            case opcodes::i64_const:
               ie.value.i64 = parse_varint64(code);
               SYS_VM_ASSERT(type == types::i64, wasm_parse_exception, "expected i64 initializer");
               break;
            case opcodes::f32_const:
               ie.value.f32 = parse_raw<uint32_t>(code);
               SYS_VM_ASSERT(type == types::f32, wasm_parse_exception, "expected f32 initializer");
               break;
            case opcodes::f64_const:
               ie.value.f64 = parse_raw<uint64_t>(code);
               SYS_VM_ASSERT(type == types::f64, wasm_parse_exception, "expected f64 initializer");
               break;
            default:
               SYS_VM_ASSERT(false, wasm_parse_exception,
                             "initializer expression can only acception i32.const, i64.const, f32.const and f64.const");
         }
         SYS_VM_ASSERT((*code++) == opcodes::end, wasm_parse_exception, "no end op found");
      }

parse_init_expr() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_init_expr ( wasm_code_ptr & code, init_expr & ie, uint8_t type )

inline

Definition at line 548 of file parser.hpp.

                                                                             {
         ie.opcode = *code++;
         switch (ie.opcode) {
            case opcodes::i32_const:
               ie.value.i32 = parse_varint32(code);
               SYS_VM_ASSERT(type == types::i32, wasm_parse_exception, "expected i32 initializer");
               break;
            case opcodes::i64_const:
               ie.value.i64 = parse_varint64(code);
               SYS_VM_ASSERT(type == types::i64, wasm_parse_exception, "expected i64 initializer");
               break;
            case opcodes::f32_const:
               ie.value.f32 = parse_raw<uint32_t>(code);
               SYS_VM_ASSERT(type == types::f32, wasm_parse_exception, "expected f32 initializer");
               break;
            case opcodes::f64_const:
               ie.value.f64 = parse_raw<uint64_t>(code);
               SYS_VM_ASSERT(type == types::f64, wasm_parse_exception, "expected f64 initializer");
               break;
            default:
               SYS_VM_ASSERT(false, wasm_parse_exception,
                             "initializer expression can only acception i32.const, i64.const, f32.const and f64.const");
         }
         SYS_VM_ASSERT((*code++) == opcodes::end, wasm_parse_exception, "no end op found");
      }

parse_magic() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_magic ( wasm_code_ptr & code )

inline

Definition at line 352 of file parser.hpp.

                                                       {
         return parse_raw<uint32_t>(code);
      }

parse_magic() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_magic ( wasm_code_ptr & code )

inline

Definition at line 352 of file parser.hpp.

                                                       {
         return parse_raw<uint32_t>(code);
      }

parse_memory_type() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_memory_type ( wasm_code_ptr & code, memory_type & mt )

inline

Definition at line 469 of file parser.hpp.

                                                                   {
         mt.limits.flags   = parse_flags(code);
         mt.limits.initial = parse_varuint32(code);
         // Implementation limits
         SYS_VM_ASSERT(mt.limits.initial <= detail::get_max_pages(_options), wasm_parse_exception, "initial memory out of range");
         // WASM specification
         SYS_VM_ASSERT(mt.limits.initial <= 65536u, wasm_parse_exception, "initial memory out of range");
         if (mt.limits.flags) {
            mt.limits.maximum = parse_varuint32(code);
            SYS_VM_ASSERT(mt.limits.maximum >= mt.limits.initial, wasm_parse_exception, "maximum must be at least minimum");
            SYS_VM_ASSERT(mt.limits.maximum <= 65536u, wasm_parse_exception, "maximum memory out of range");
         }
      }

parse_memory_type() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_memory_type ( wasm_code_ptr & code, memory_type & mt )

inline

Definition at line 469 of file parser.hpp.

                                                                   {
         mt.limits.flags   = parse_flags(code);
         mt.limits.initial = parse_varuint32(code);
         // Implementation limits
         SYS_VM_ASSERT(mt.limits.initial <= detail::get_max_pages(_options), wasm_parse_exception, "initial memory out of range");
         // WASM specification
         SYS_VM_ASSERT(mt.limits.initial <= 65536u, wasm_parse_exception, "initial memory out of range");
         if (mt.limits.flags) {
            mt.limits.maximum = parse_varuint32(code);
            SYS_VM_ASSERT(mt.limits.maximum >= mt.limits.initial, wasm_parse_exception, "maximum must be at least minimum");
            SYS_VM_ASSERT(mt.limits.maximum <= 65536u, wasm_parse_exception, "maximum memory out of range");
         }
      }

parse_module() [1/4]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

module & sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_module ( wasm_code & code, module & mod, DebugInfo & debug )

inline

Definition at line 292 of file parser.hpp.

                                                                                  {
         wasm_code_ptr cp(code.data(), code.size());
         parse_module(cp, code.size(), mod, debug);
         return mod;
      }

Here is the caller graph for this function:

parse_module() [2/4]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

module & sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_module ( wasm_code & code, module & mod, DebugInfo & debug )

inline

Definition at line 292 of file parser.hpp.

                                                                                  {
         wasm_code_ptr cp(code.data(), code.size());
         parse_module(cp, code.size(), mod, debug);
         return mod;
      }

parse_module() [3/4]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_module ( wasm_code_ptr & code_ptr, size_t sz, module & mod, DebugInfo & debug )

inline

Definition at line 303 of file parser.hpp.

                                                                                           {
         _mod = &mod;
         SYS_VM_ASSERT(parse_magic(code_ptr) == constants::magic, wasm_parse_exception, "magic number did not match");
         SYS_VM_ASSERT(parse_version(code_ptr) == constants::version, wasm_parse_exception,
                       "version number did not match");
         uint8_t highest_section_id = 0;
         for (;;) {
            if (code_ptr.offset() == sz)
               break;
            auto id = parse_section_id(code_ptr);
            auto len = parse_section_payload_len(code_ptr);
 
            SYS_VM_ASSERT(id == 0 || id > highest_section_id, wasm_parse_exception, "section out of order");
            highest_section_id = std::max(highest_section_id, id);
 
            auto section_guard = code_ptr.scoped_consume_items(len);
 
            switch (id) {
               case section_id::custom_section: parse_custom(code_ptr); break;
               case section_id::type_section: parse_section<section_id::type_section>(code_ptr, mod.types); break;
               case section_id::import_section: parse_section<section_id::import_section>(code_ptr, mod.imports); break;
               case section_id::function_section:
                  parse_section<section_id::function_section>(code_ptr, mod.functions);
                  mod.normalize_types();
                  break;
               case section_id::table_section: parse_section<section_id::table_section>(code_ptr, mod.tables); break;
               case section_id::memory_section:
                  parse_section<section_id::memory_section>(code_ptr, mod.memories);
                  break;
               case section_id::global_section: parse_section<section_id::global_section>(code_ptr, mod.globals); break;
               case section_id::export_section:
                  parse_section<section_id::export_section>(code_ptr, mod.exports);
                  validate_exports();
                  break;
               case section_id::start_section: parse_section<section_id::start_section>(code_ptr, mod.start); break;
               case section_id::element_section:
                  parse_section<section_id::element_section>(code_ptr, mod.elements);
                  break;
               case section_id::code_section: parse_section<section_id::code_section>(code_ptr, mod.code); break;
               case section_id::data_section: parse_section<section_id::data_section>(code_ptr, mod.data); break;
               default: SYS_VM_ASSERT(false, wasm_parse_exception, "error invalid section id");
            }
         }
         SYS_VM_ASSERT(_mod->code.size() == _mod->functions.size(), wasm_parse_exception, "code section must have the same size as the function section" );
 
         debug.set(std::move(imap));
         debug.relocate(_allocator.get_code_start());
      }

Here is the call graph for this function:

parse_module() [4/4]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_module ( wasm_code_ptr & code_ptr, size_t sz, module & mod, DebugInfo & debug )

inline

Definition at line 303 of file parser.hpp.

                                                                                           {
         _mod = &mod;
         SYS_VM_ASSERT(parse_magic(code_ptr) == constants::magic, wasm_parse_exception, "magic number did not match");
         SYS_VM_ASSERT(parse_version(code_ptr) == constants::version, wasm_parse_exception,
                       "version number did not match");
         uint8_t highest_section_id = 0;
         for (;;) {
            if (code_ptr.offset() == sz)
               break;
            auto id = parse_section_id(code_ptr);
            auto len = parse_section_payload_len(code_ptr);
 
            SYS_VM_ASSERT(id == 0 || id > highest_section_id, wasm_parse_exception, "section out of order");
            highest_section_id = std::max(highest_section_id, id);
 
            auto section_guard = code_ptr.scoped_consume_items(len);
 
            switch (id) {
               case section_id::custom_section: parse_custom(code_ptr); break;
               case section_id::type_section: parse_section<section_id::type_section>(code_ptr, mod.types); break;
               case section_id::import_section: parse_section<section_id::import_section>(code_ptr, mod.imports); break;
               case section_id::function_section:
                  parse_section<section_id::function_section>(code_ptr, mod.functions);
                  mod.normalize_types();
                  break;
               case section_id::table_section: parse_section<section_id::table_section>(code_ptr, mod.tables); break;
               case section_id::memory_section:
                  parse_section<section_id::memory_section>(code_ptr, mod.memories);
                  break;
               case section_id::global_section: parse_section<section_id::global_section>(code_ptr, mod.globals); break;
               case section_id::export_section:
                  parse_section<section_id::export_section>(code_ptr, mod.exports);
                  validate_exports();
                  break;
               case section_id::start_section: parse_section<section_id::start_section>(code_ptr, mod.start); break;
               case section_id::element_section:
                  parse_section<section_id::element_section>(code_ptr, mod.elements);
                  break;
               case section_id::code_section: parse_section<section_id::code_section>(code_ptr, mod.code); break;
               case section_id::data_section: parse_section<section_id::data_section>(code_ptr, mod.data); break;
               default: SYS_VM_ASSERT(false, wasm_parse_exception, "error invalid section id");
            }
         }
         SYS_VM_ASSERT(_mod->code.size() == _mod->functions.size(), wasm_parse_exception, "code section must have the same size as the function section" );
 
         debug.set(std::move(imap));
         debug.relocate(_allocator.get_code_start());
      }

Here is the call graph for this function:

parse_module2() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

module & sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_module2 ( wasm_code_ptr & code_ptr, size_t sz, module & mod, DebugInfo & debug )

inline

Definition at line 298 of file parser.hpp.

                                                                                                      {
         parse_module(code_ptr, sz, mod, debug);
         return mod;
      }

parse_module2() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

module & sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_module2 ( wasm_code_ptr & code_ptr, size_t sz, module & mod, DebugInfo & debug )

inline

Definition at line 298 of file parser.hpp.

                                                                                                      {
         parse_module(code_ptr, sz, mod, debug);
         return mod;
      }

parse_name_map() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_name_map ( wasm_code_ptr & code, guarded_vector< name_assoc > & map )

inline

Definition at line 374 of file parser.hpp.

                                                                                       {
        for(uint32_t i = 0; i < map.size(); ++i) {
            map[i].idx = parse_varuint32(code);
            map[i].name = parse_utf8_string(code, 0xFFFFFFFFu);
         }
      }

parse_name_map() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_name_map ( wasm_code_ptr & code, guarded_vector< name_assoc > & map )

inline

Definition at line 374 of file parser.hpp.

                                                                                       {
        for(uint32_t i = 0; i < map.size(); ++i) {
            map[i].idx = parse_varuint32(code);
            map[i].name = parse_utf8_string(code, 0xFFFFFFFFu);
         }
      }

parse_name_section() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_name_section ( wasm_code_ptr & code )

inline

Definition at line 381 of file parser.hpp.

                                                          {
         _mod->names = _allocator.alloc<name_section>(1);
         new (_mod->names) name_section;
         if(code.bounds() == code.offset()) return;
         if(*code == 0) {
            ++code;
            auto subsection_guard = code.scoped_consume_items(parse_varuint32(code));
            _mod->names->module_name = _allocator.alloc<guarded_vector<uint8_t>>(1);
            new (_mod->names->module_name) guarded_vector<uint8_t>(parse_utf8_string(code, 0xFFFFFFFFu));
         }
         if(code.bounds() == code.offset()) return;
         if(*code == 1) {
            ++code;
            auto subsection_guard = code.scoped_consume_items(parse_varuint32(code));
            uint32_t size = parse_varuint32(code);
            _mod->names->function_names = _allocator.alloc<guarded_vector<name_assoc>>(1);
            new (_mod->names->function_names) guarded_vector<name_assoc>(_allocator, size);
            parse_name_map(code, *_mod->names->function_names);
         }
         if(code.bounds() == code.offset()) return;
         if(*code == 2) {
            ++code;
            auto subsection_guard = code.scoped_consume_items(parse_varuint32(code));
            uint32_t size = parse_varuint32(code);
            _mod->names->local_names = _allocator.alloc<guarded_vector<indirect_name_assoc>>(1);
            new (_mod->names->local_names) guarded_vector<indirect_name_assoc>(_allocator, size);
            for(uint32_t i = 0; i < size; ++i) {
               auto& [idx,namemap] = (*_mod->names->local_names)[i];
               idx = parse_varuint32(code);
               uint32_t local_size = parse_varuint32(code);
               namemap = guarded_vector<name_assoc>(_allocator, local_size);
               parse_name_map(code, namemap);
            }
         }
         if(code.bounds() == code.offset()) return;
         SYS_VM_ASSERT(false, wasm_parse_exception, "Invalid subsection Id");
      }

parse_name_section() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_name_section ( wasm_code_ptr & code )

inline

Definition at line 381 of file parser.hpp.

                                                          {
         _mod->names = _allocator.alloc<name_section>(1);
         new (_mod->names) name_section;
         if(code.bounds() == code.offset()) return;
         if(*code == 0) {
            ++code;
            auto subsection_guard = code.scoped_consume_items(parse_varuint32(code));
            _mod->names->module_name = _allocator.alloc<guarded_vector<uint8_t>>(1);
            new (_mod->names->module_name) guarded_vector<uint8_t>(parse_utf8_string(code, 0xFFFFFFFFu));
         }
         if(code.bounds() == code.offset()) return;
         if(*code == 1) {
            ++code;
            auto subsection_guard = code.scoped_consume_items(parse_varuint32(code));
            uint32_t size = parse_varuint32(code);
            _mod->names->function_names = _allocator.alloc<guarded_vector<name_assoc>>(1);
            new (_mod->names->function_names) guarded_vector<name_assoc>(_allocator, size);
            parse_name_map(code, *_mod->names->function_names);
         }
         if(code.bounds() == code.offset()) return;
         if(*code == 2) {
            ++code;
            auto subsection_guard = code.scoped_consume_items(parse_varuint32(code));
            uint32_t size = parse_varuint32(code);
            _mod->names->local_names = _allocator.alloc<guarded_vector<indirect_name_assoc>>(1);
            new (_mod->names->local_names) guarded_vector<indirect_name_assoc>(_allocator, size);
            for(uint32_t i = 0; i < size; ++i) {
               auto& [idx,namemap] = (*_mod->names->local_names)[i];
               idx = parse_varuint32(code);
               uint32_t local_size = parse_varuint32(code);
               namemap = guarded_vector<name_assoc>(_allocator, local_size);
               parse_name_map(code, namemap);
            }
         }
         if(code.bounds() == code.offset()) return;
         SYS_VM_ASSERT(false, wasm_parse_exception, "Invalid subsection Id");
      }

parse_raw() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<typename T >

T sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_raw ( wasm_code_ptr & code )

inline

Definition at line 283 of file parser.hpp.

                                       {
         static_assert(std::is_arithmetic_v<T>, "Can only read builtin types");
         auto guard = code.scoped_shrink_bounds(sizeof(T));
         T result;
         memcpy(&result, code.raw(), sizeof(T));
         code += sizeof(T);
         return result;
      }

Here is the call graph for this function:

parse_raw() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<typename T >

T sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_raw ( wasm_code_ptr & code )

inline

Definition at line 283 of file parser.hpp.

                                       {
         static_assert(std::is_arithmetic_v<T>, "Can only read builtin types");
         auto guard = code.scoped_shrink_bounds(sizeof(T));
         T result;
         memcpy(&result, code.raw(), sizeof(T));
         code += sizeof(T);
         return result;
      }

Here is the call graph for this function:

parse_section() [1/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, typename std::enable_if_t< id==section_id::start_section, uint32_t > & start )

inline

Definition at line 1297 of file parser.hpp.

                                                                                                         {
         start = parse_varuint32(code);
         const func_type& ft = _mod->get_function_type(start);
         SYS_VM_ASSERT(ft.return_count == 0 && ft.param_types.size() == 0, wasm_parse_exception, "wrong type for start");
      }

parse_section() [2/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, typename std::enable_if_t< id==section_id::start_section, uint32_t > & start )

inline

Definition at line 1297 of file parser.hpp.

                                                                                                         {
         start = parse_varuint32(code);
         const func_type& ft = _mod->get_function_type(start);
         SYS_VM_ASSERT(ft.return_count == 0 && ft.param_types.size() == 0, wasm_parse_exception, "wrong type for start");
      }

parse_section() [3/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::code_section, function_body > > & elems )

inline

Definition at line 1311 of file parser.hpp.

                                                                                                                  {
         const void* code_start = code.raw() - code.offset();
         parse_section_impl(code, elems, detail::get_max_function_section_elements(_options),
                            [&](wasm_code_ptr& code, function_body& fb, std::size_t idx) { parse_function_body(code, fb, idx); });
         SYS_VM_ASSERT( elems.size() == _mod->functions.size(), wasm_parse_exception, "code section must have the same size as the function section" );
         Writer code_writer(_allocator, code.bounds() - code.offset(), *_mod);
         imap.on_code_start(code_writer.get_base_addr(), code_start);
         for (size_t i = 0; i < _function_bodies.size(); i++) {
            function_body& fb = _mod->code[i];
            func_type& ft = _mod->types.at(_mod->functions.at(i));
            local_types_t local_types(ft, fb.locals);
            imap.on_function_start(code_writer.get_addr(), _function_bodies[i].first.raw());
            code_writer.emit_prologue(ft, fb.locals, i);
            parse_function_body_code(_function_bodies[i].first, fb.size, _function_bodies[i].second, code_writer, ft, local_types);
            code_writer.emit_epilogue(ft, fb.locals, i);
            code_writer.finalize(fb);
         }
         imap.on_code_end(code_writer.get_addr(), code.raw());
      }

parse_section() [4/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::code_section, function_body > > & elems )

inline

Definition at line 1311 of file parser.hpp.

                                                                                                                  {
         const void* code_start = code.raw() - code.offset();
         parse_section_impl(code, elems, detail::get_max_function_section_elements(_options),
                            [&](wasm_code_ptr& code, function_body& fb, std::size_t idx) { parse_function_body(code, fb, idx); });
         SYS_VM_ASSERT( elems.size() == _mod->functions.size(), wasm_parse_exception, "code section must have the same size as the function section" );
         Writer code_writer(_allocator, code.bounds() - code.offset(), *_mod);
         imap.on_code_start(code_writer.get_base_addr(), code_start);
         for (size_t i = 0; i < _function_bodies.size(); i++) {
            function_body& fb = _mod->code[i];
            func_type& ft = _mod->types.at(_mod->functions.at(i));
            local_types_t local_types(ft, fb.locals);
            imap.on_function_start(code_writer.get_addr(), _function_bodies[i].first.raw());
            code_writer.emit_prologue(ft, fb.locals, i);
            parse_function_body_code(_function_bodies[i].first, fb.size, _function_bodies[i].second, code_writer, ft, local_types);
            code_writer.emit_epilogue(ft, fb.locals, i);
            code_writer.finalize(fb);
         }
         imap.on_code_end(code_writer.get_addr(), code.raw());
      }

parse_section() [5/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::data_section, data_segment > > & elems )

inline

Definition at line 1332 of file parser.hpp.

                                                                                                                 {
         parse_section_impl(code, elems, detail::get_max_data_section_elements(_options),
                            [&](wasm_code_ptr& code, data_segment& ds, std::size_t /*idx*/) { parse_data_segment(code, ds); });
      }

parse_section() [6/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::data_section, data_segment > > & elems )

inline

Definition at line 1332 of file parser.hpp.

                                                                                                                 {
         parse_section_impl(code, elems, detail::get_max_data_section_elements(_options),
                            [&](wasm_code_ptr& code, data_segment& ds, std::size_t /*idx*/) { parse_data_segment(code, ds); });
      }

parse_section() [7/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::element_section, elem_segment > > & elems )

inline

Definition at line 1305 of file parser.hpp.

                                                                                                        {
         parse_section_impl(code, elems, detail::get_max_element_section_elements(_options),
                            [&](wasm_code_ptr& code, elem_segment& es, std::size_t /*idx*/) { parse_elem_segment(code, es); });
      }

parse_section() [8/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::element_section, elem_segment > > & elems )

inline

Definition at line 1305 of file parser.hpp.

                                                                                                        {
         parse_section_impl(code, elems, detail::get_max_element_section_elements(_options),
                            [&](wasm_code_ptr& code, elem_segment& es, std::size_t /*idx*/) { parse_elem_segment(code, es); });
      }

parse_section() [9/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::export_section, export_entry > > & elems )

inline

Definition at line 1291 of file parser.hpp.

                                                                                                                   {
         parse_section_impl(code, elems, detail::get_max_export_section_elements(_options),
                            [&](wasm_code_ptr& code, export_entry& ee, std::size_t /*idx*/) { parse_export_entry(code, ee); });
      }

parse_section() [10/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::export_section, export_entry > > & elems )

inline

Definition at line 1291 of file parser.hpp.

                                                                                                                   {
         parse_section_impl(code, elems, detail::get_max_export_section_elements(_options),
                            [&](wasm_code_ptr& code, export_entry& ee, std::size_t /*idx*/) { parse_export_entry(code, ee); });
      }

parse_section() [11/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::function_section, uint32_t > > & elems )

inline

Definition at line 1264 of file parser.hpp.

                                                                                                                 {
         parse_section_impl(code, elems, detail::get_max_function_section_elements(_options),
                            [&](wasm_code_ptr& code, uint32_t& elem, std::size_t /*idx*/) { elem = parse_varuint32(code); });
      }

parse_section() [12/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::function_section, uint32_t > > & elems )

inline

Definition at line 1264 of file parser.hpp.

                                                                                                                 {
         parse_section_impl(code, elems, detail::get_max_function_section_elements(_options),
                            [&](wasm_code_ptr& code, uint32_t& elem, std::size_t /*idx*/) { elem = parse_varuint32(code); });
      }

parse_section() [13/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::global_section, global_variable > > & elems )

inline

Definition at line 1285 of file parser.hpp.

                                                                                                          {
         parse_section_impl(code, elems, detail::get_max_global_section_elements(_options),
                            [&](wasm_code_ptr& code, global_variable& gv, std::size_t /*idx*/) { parse_global_variable(code, gv); });
      }

parse_section() [14/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::global_section, global_variable > > & elems )

inline

Definition at line 1285 of file parser.hpp.

                                                                                                          {
         parse_section_impl(code, elems, detail::get_max_global_section_elements(_options),
                            [&](wasm_code_ptr& code, global_variable& gv, std::size_t /*idx*/) { parse_global_variable(code, gv); });
      }

parse_section() [15/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::import_section, import_entry > > & elems )

inline

Definition at line 1258 of file parser.hpp.

                                                                                                                   {
         parse_section_impl(code, elems, detail::get_max_import_section_elements(_options),
                            [&](wasm_code_ptr& code, import_entry& ie, std::size_t /*idx*/) { parse_import_entry(code, ie); });
      }

parse_section() [16/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::import_section, import_entry > > & elems )

inline

Definition at line 1258 of file parser.hpp.

                                                                                                                   {
         parse_section_impl(code, elems, detail::get_max_import_section_elements(_options),
                            [&](wasm_code_ptr& code, import_entry& ie, std::size_t /*idx*/) { parse_import_entry(code, ie); });
      }

parse_section() [17/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::memory_section, memory_type > > & elems )

inline

Definition at line 1276 of file parser.hpp.

                                                                                                                  {
         parse_section_impl(code, elems, 1, [&](wasm_code_ptr& code, memory_type& mt, std::size_t idx) {
            SYS_VM_ASSERT(idx == 0, wasm_parse_exception, "only one memory is permitted");
            parse_memory_type(code, mt);
         });
      }

parse_section() [18/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::memory_section, memory_type > > & elems )

inline

Definition at line 1276 of file parser.hpp.

                                                                                                                  {
         parse_section_impl(code, elems, 1, [&](wasm_code_ptr& code, memory_type& mt, std::size_t idx) {
            SYS_VM_ASSERT(idx == 0, wasm_parse_exception, "only one memory is permitted");
            parse_memory_type(code, mt);
         });
      }

parse_section() [19/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::table_section, table_type > > & elems )

inline

Definition at line 1270 of file parser.hpp.

                                                                                                                {
         parse_section_impl(code, elems, 1,
                            [&](wasm_code_ptr& code, table_type& tt, std::size_t /*idx*/) { parse_table_type(code, tt); });
      }

parse_section() [20/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::table_section, table_type > > & elems )

inline

Definition at line 1270 of file parser.hpp.

                                                                                                                {
         parse_section_impl(code, elems, 1,
                            [&](wasm_code_ptr& code, table_type& tt, std::size_t /*idx*/) { parse_table_type(code, tt); });
      }

parse_section() [21/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::type_section, func_type > > & elems )

inline

Definition at line 1252 of file parser.hpp.

                                                                                                              {
         parse_section_impl(code, elems, detail::get_max_type_section_elements(_options),
                            [&](wasm_code_ptr& code, func_type& ft, std::size_t /*idx*/) { parse_func_type(code, ft); });
      }

parse_section() [22/22]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<uint8_t id>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section ( wasm_code_ptr & code, vec< typename std::enable_if_t< id==section_id::type_section, func_type > > & elems )

inline

Definition at line 1252 of file parser.hpp.

                                                                                                              {
         parse_section_impl(code, elems, detail::get_max_type_section_elements(_options),
                            [&](wasm_code_ptr& code, func_type& ft, std::size_t /*idx*/) { parse_func_type(code, ft); });
      }

parse_section_id() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section_id ( wasm_code_ptr & code )

inline

Definition at line 358 of file parser.hpp.

{ return *code++; }

parse_section_id() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section_id ( wasm_code_ptr & code )

inline

Definition at line 358 of file parser.hpp.

{ return *code++; }

parse_section_impl() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<typename Elem , typename ParseFunc >

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section_impl ( wasm_code_ptr & code, vec< Elem > & elems, std::uint32_t max_elements, ParseFunc && elem_parse )

inline

Definition at line 1244 of file parser.hpp.

                                                                                                                              {
         auto count = parse_varuint32(code);
         SYS_VM_ASSERT(count <= max_elements, wasm_parse_exception, "number of section elements exceeded limit");
         elems      = vec<Elem>{ _allocator, count };
         for (size_t i = 0; i < count; i++) { elem_parse(code, elems.at(i), i); }
      }

Here is the call graph for this function:

parse_section_impl() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<typename Elem , typename ParseFunc >

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section_impl ( wasm_code_ptr & code, vec< Elem > & elems, std::uint32_t max_elements, ParseFunc && elem_parse )

inline

Definition at line 1244 of file parser.hpp.

                                                                                                                              {
         auto count = parse_varuint32(code);
         SYS_VM_ASSERT(count <= max_elements, wasm_parse_exception, "number of section elements exceeded limit");
         elems      = vec<Elem>{ _allocator, count };
         for (size_t i = 0; i < count; i++) { elem_parse(code, elems.at(i), i); }
      }

Here is the call graph for this function:

parse_section_payload_len() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section_payload_len ( wasm_code_ptr & code )

inline

Definition at line 359 of file parser.hpp.

                                                                     {
         return parse_varuint32(code);
      }

parse_section_payload_len() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_section_payload_len ( wasm_code_ptr & code )

inline

Definition at line 359 of file parser.hpp.

                                                                     {
         return parse_varuint32(code);
      }

parse_table_type() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_table_type ( wasm_code_ptr & code, table_type & tt )

inline

Definition at line 442 of file parser.hpp.

                                                                 {
         tt.element_type   = *code++;
         SYS_VM_ASSERT(tt.element_type == types::anyfunc, wasm_parse_exception, "table must have type anyfunc");
         tt.limits.flags   = parse_flags(code);
         tt.limits.initial = parse_varuint32(code);
         if (tt.limits.flags) {
            tt.limits.maximum = parse_varuint32(code);
            SYS_VM_ASSERT(tt.limits.initial <= tt.limits.maximum, wasm_parse_exception, "table max size less than min size");
         }
         SYS_VM_ASSERT(tt.limits.initial <= detail::get_max_table_elements(_options), wasm_parse_exception, "table size exceeds limit");
         tt.table = decltype(tt.table){ _allocator, tt.limits.initial };
         for (uint32_t i = 0; i < tt.limits.initial; i++) tt.table[i] = std::numeric_limits<uint32_t>::max();
      }

parse_table_type() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_table_type ( wasm_code_ptr & code, table_type & tt )

inline

Definition at line 442 of file parser.hpp.

                                                                 {
         tt.element_type   = *code++;
         SYS_VM_ASSERT(tt.element_type == types::anyfunc, wasm_parse_exception, "table must have type anyfunc");
         tt.limits.flags   = parse_flags(code);
         tt.limits.initial = parse_varuint32(code);
         if (tt.limits.flags) {
            tt.limits.maximum = parse_varuint32(code);
            SYS_VM_ASSERT(tt.limits.initial <= tt.limits.maximum, wasm_parse_exception, "table max size less than min size");
         }
         SYS_VM_ASSERT(tt.limits.initial <= detail::get_max_table_elements(_options), wasm_parse_exception, "table size exceeds limit");
         tt.table = decltype(tt.table){ _allocator, tt.limits.initial };
         for (uint32_t i = 0; i < tt.limits.initial; i++) tt.table[i] = std::numeric_limits<uint32_t>::max();
      }

parse_utf8_string() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

guarded_vector< uint8_t > sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_utf8_string ( wasm_code_ptr & code, std::uint32_t max_size )

inline

Definition at line 272 of file parser.hpp.

                                                                                           {
         auto len        = parse_varuint32(code);
         SYS_VM_ASSERT(len <= max_size, wasm_parse_exception, "name too long");
         auto guard = code.scoped_shrink_bounds(len);
         auto result = guarded_vector<uint8_t>{ _allocator, len };
         result.copy(code.raw(), len);
         validate_utf8_string(code, len);
         return result;
      }

Here is the call graph for this function:

parse_utf8_string() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

guarded_vector< uint8_t > sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_utf8_string ( wasm_code_ptr & code, std::uint32_t max_size )

inline

Definition at line 272 of file parser.hpp.

                                                                                           {
         auto len        = parse_varuint32(code);
         SYS_VM_ASSERT(len <= max_size, wasm_parse_exception, "name too long");
         auto guard = code.scoped_shrink_bounds(len);
         auto result = guarded_vector<uint8_t>{ _allocator, len };
         result.copy(code.raw(), len);
         validate_utf8_string(code, len);
         return result;
      }

Here is the call graph for this function:

parse_varint() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<size_t N>

varint< N > sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint ( const wasm_code & code, size_t index )

inline

Definition at line 1339 of file parser.hpp.

                                                                  {
         varint<N> result(0);
         result.set(code, index);
         return result;
      }

parse_varint() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<size_t N>

varint< N > sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint ( const wasm_code & code, size_t index )

inline

Definition at line 1339 of file parser.hpp.

                                                                  {
         varint<N> result(0);
         result.set(code, index);
         return result;
      }

parse_varint32() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static int32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint32 ( wasm_code_ptr & code )

inlinestatic

Definition at line 217 of file parser.hpp.

{ return varint<32>(code).to(); }

Here is the call graph for this function:

parse_varint32() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static int32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint32 ( wasm_code_ptr & code )

inlinestatic

Definition at line 217 of file parser.hpp.

{ return varint<32>(code).to(); }

Here is the call graph for this function:

parse_varint64() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static int64_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint64 ( wasm_code_ptr & code )

inlinestatic

Definition at line 219 of file parser.hpp.

{ return varint<64>(code).to(); }

Here is the call graph for this function:

parse_varint64() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static int64_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint64 ( wasm_code_ptr & code )

inlinestatic

Definition at line 219 of file parser.hpp.

{ return varint<64>(code).to(); }

Here is the call graph for this function:

parse_varint7() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static int8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint7 ( wasm_code_ptr & code )

inlinestatic

Definition at line 215 of file parser.hpp.

{ return varint<7>(code).to(); }

Here is the call graph for this function:

parse_varint7() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static int8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varint7 ( wasm_code_ptr & code )

inlinestatic

Definition at line 215 of file parser.hpp.

{ return varint<7>(code).to(); }

Here is the call graph for this function:

parse_varuint() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<size_t N>

varuint< N > sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint ( const wasm_code & code, size_t index )

inline

Definition at line 1346 of file parser.hpp.

                                                                    {
         varuint<N> result(0);
         result.set(code, index);
         return result;
      }

parse_varuint() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<size_t N>

varuint< N > sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint ( const wasm_code & code, size_t index )

inline

Definition at line 1346 of file parser.hpp.

                                                                    {
         varuint<N> result(0);
         result.set(code, index);
         return result;
      }

parse_varuint1() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint1 ( wasm_code_ptr & code )

inlinestatic

Definition at line 209 of file parser.hpp.

{ return varuint<1>(code).to(); }

Here is the call graph for this function:

parse_varuint1() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint1 ( wasm_code_ptr & code )

inlinestatic

Definition at line 209 of file parser.hpp.

{ return varuint<1>(code).to(); }

Here is the call graph for this function:

parse_varuint32() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint32 ( wasm_code_ptr & code )

inlinestatic

Definition at line 213 of file parser.hpp.

{ return varuint<32>(code).to(); }

Here is the call graph for this function:

Here is the caller graph for this function:

parse_varuint32() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint32 ( wasm_code_ptr & code )

inlinestatic

Definition at line 213 of file parser.hpp.

{ return varuint<32>(code).to(); }

Here is the call graph for this function:

parse_varuint7() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint7 ( wasm_code_ptr & code )

inlinestatic

Definition at line 211 of file parser.hpp.

{ return varuint<7>(code).to(); }

Here is the call graph for this function:

parse_varuint7() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_varuint7 ( wasm_code_ptr & code )

inlinestatic

Definition at line 211 of file parser.hpp.

{ return varuint<7>(code).to(); }

Here is the call graph for this function:

parse_version() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_version ( wasm_code_ptr & code )

inline

Definition at line 355 of file parser.hpp.

                                                         {
         return parse_raw<uint32_t>(code);
      }

parse_version() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

uint32_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::parse_version ( wasm_code_ptr & code )

inline

Definition at line 355 of file parser.hpp.

                                                         {
         return parse_raw<uint32_t>(code);
      }

validate_exports() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::validate_exports ( ) const

inline

Definition at line 1356 of file parser.hpp.

                                    {
         std::vector<const guarded_vector<uint8_t>*> export_names;
         export_names.reserve(_mod->exports.size());
         for (uint32_t i = 0; i < _mod->exports.size(); ++i) {
            export_names.push_back(&_mod->exports[i].field_str);
         }
         std::sort(export_names.begin(), export_names.end(), [](auto* lhs, auto* rhs) {
            return std::lexicographical_compare(lhs->raw(), lhs->raw() + lhs->size(), rhs->raw(), rhs->raw() + rhs->size());
         });
         auto it = std::adjacent_find(export_names.begin(), export_names.end(), [](auto* lhs, auto* rhs) {
            return lhs->size() == rhs->size() && std::equal(lhs->raw(), lhs->raw() + lhs->size(), rhs->raw());
         });
         SYS_VM_ASSERT(it == export_names.end(), wasm_parse_exception, "duplicate export name");
      }

validate_exports() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::validate_exports ( ) const

inline

Definition at line 1356 of file parser.hpp.

                                    {
         std::vector<const guarded_vector<uint8_t>*> export_names;
         export_names.reserve(_mod->exports.size());
         for (uint32_t i = 0; i < _mod->exports.size(); ++i) {
            export_names.push_back(&_mod->exports[i].field_str);
         }
         std::sort(export_names.begin(), export_names.end(), [](auto* lhs, auto* rhs) {
            return std::lexicographical_compare(lhs->raw(), lhs->raw() + lhs->size(), rhs->raw(), rhs->raw() + rhs->size());
         });
         auto it = std::adjacent_find(export_names.begin(), export_names.end(), [](auto* lhs, auto* rhs) {
            return lhs->size() == rhs->size() && std::equal(lhs->raw(), lhs->raw() + lhs->size(), rhs->raw());
         });
         SYS_VM_ASSERT(it == export_names.end(), wasm_parse_exception, "duplicate export name");
      }

validate_utf8_code_point() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

int sysio::vm::binary_parser< Writer, Options, DebugInfo >::validate_utf8_code_point ( wasm_code_ptr & code )

inline

Definition at line 221 of file parser.hpp.

                                                        {
         unsigned char ch = *code++;
         if (ch < 0x80) {
            return 1;
         } else if(ch < 0xE0) {
           SYS_VM_ASSERT((ch & 0xC0) == 0xC0, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b2 = *code++;
            SYS_VM_ASSERT((b2 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            uint32_t code_point =
              (static_cast<uint32_t>(ch - 0xC0u) << 6u) +
              (static_cast<uint32_t>(b2 - 0x80u));
            SYS_VM_ASSERT(0x80 <= code_point && code_point < 0x800, wasm_parse_exception, "invalid utf8 encoding");
            return 2;
         } else if(ch < 0xF0) {
            unsigned char b2 = *code++;
            SYS_VM_ASSERT((b2 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b3 = *code++;
            SYS_VM_ASSERT((b3 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            uint32_t code_point =
              (static_cast<uint32_t>(ch - 0xE0u) << 12u) +
              (static_cast<uint32_t>(b2 - 0x80u) << 6u) +
              (static_cast<uint32_t>(b3 - 0x80u));
            SYS_VM_ASSERT((0x800 <= code_point && code_point < 0xD800) ||
                          (0xE000 <= code_point && code_point < 0x10000),
                          wasm_parse_exception, "invalid utf8 encoding");
            return 3;
         } else if (ch < 0xF8) {
            unsigned char b2 = *code++;
            SYS_VM_ASSERT((b2 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b3 = *code++;
            SYS_VM_ASSERT((b3 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b4 = *code++;
            SYS_VM_ASSERT((b4 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            uint32_t code_point =
              (static_cast<uint32_t>(ch - 0xF0u) << 18u) +
              (static_cast<uint32_t>(b2 - 0x80u) << 12u) +
              (static_cast<uint32_t>(b3 - 0x80u) << 6u) +
              (static_cast<uint32_t>(b4 - 0x80u));
            SYS_VM_ASSERT((0x10000 <= code_point && code_point < 0x110000),
                          wasm_parse_exception, "invalid utf8 encoding");
            return 4;
         }
         SYS_VM_ASSERT(false, wasm_parse_exception, "invalid utf8 encoding");
      }

Here is the caller graph for this function:

validate_utf8_code_point() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

int sysio::vm::binary_parser< Writer, Options, DebugInfo >::validate_utf8_code_point ( wasm_code_ptr & code )

inline

Definition at line 221 of file parser.hpp.

                                                        {
         unsigned char ch = *code++;
         if (ch < 0x80) {
            return 1;
         } else if(ch < 0xE0) {
           SYS_VM_ASSERT((ch & 0xC0) == 0xC0, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b2 = *code++;
            SYS_VM_ASSERT((b2 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            uint32_t code_point =
              (static_cast<uint32_t>(ch - 0xC0u) << 6u) +
              (static_cast<uint32_t>(b2 - 0x80u));
            SYS_VM_ASSERT(0x80 <= code_point && code_point < 0x800, wasm_parse_exception, "invalid utf8 encoding");
            return 2;
         } else if(ch < 0xF0) {
            unsigned char b2 = *code++;
            SYS_VM_ASSERT((b2 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b3 = *code++;
            SYS_VM_ASSERT((b3 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            uint32_t code_point =
              (static_cast<uint32_t>(ch - 0xE0u) << 12u) +
              (static_cast<uint32_t>(b2 - 0x80u) << 6u) +
              (static_cast<uint32_t>(b3 - 0x80u));
            SYS_VM_ASSERT((0x800 <= code_point && code_point < 0xD800) ||
                          (0xE000 <= code_point && code_point < 0x10000),
                          wasm_parse_exception, "invalid utf8 encoding");
            return 3;
         } else if (ch < 0xF8) {
            unsigned char b2 = *code++;
            SYS_VM_ASSERT((b2 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b3 = *code++;
            SYS_VM_ASSERT((b3 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            unsigned char b4 = *code++;
            SYS_VM_ASSERT((b4 & 0xC0) == 0x80, wasm_parse_exception, "invalid utf8 encoding");
            uint32_t code_point =
              (static_cast<uint32_t>(ch - 0xF0u) << 18u) +
              (static_cast<uint32_t>(b2 - 0x80u) << 12u) +
              (static_cast<uint32_t>(b3 - 0x80u) << 6u) +
              (static_cast<uint32_t>(b4 - 0x80u));
            SYS_VM_ASSERT((0x10000 <= code_point && code_point < 0x110000),
                          wasm_parse_exception, "invalid utf8 encoding");
            return 4;
         }
         SYS_VM_ASSERT(false, wasm_parse_exception, "invalid utf8 encoding");
      }

validate_utf8_string() [1/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::validate_utf8_string ( wasm_code_ptr & code, uint32_t bytes )

inline

Definition at line 266 of file parser.hpp.

                                                                     {
         while(bytes != 0) {
            bytes -= validate_utf8_code_point(code);
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

validate_utf8_string() [2/2]

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

void sysio::vm::binary_parser< Writer, Options, DebugInfo >::validate_utf8_string ( wasm_code_ptr & code, uint32_t bytes )

inline

Definition at line 266 of file parser.hpp.

                                                                     {
         while(bytes != 0) {
            bytes -= validate_utf8_code_point(code);
         }
      }

Here is the call graph for this function:

vec()

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

template<typename T >

typedef guarded_vector<T> sysio::vm::binary_parser< Writer, Options, DebugInfo >::vec

Definition at line 207 of file parser.hpp.

Member Data Documentation

any_type

template<typename Writer , typename Options = default_options, typename DebugInfo = null_debug_info>

static constexpr uint8_t sysio::vm::binary_parser< Writer, Options, DebugInfo >::any_type = 0x82

staticconstexpr

Definition at line 623 of file parser.hpp.

---

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

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