WASM Namespace Reference

Classes
struct	LocalSet
struct	OperatorSerializerStream
struct	scoped_skip_checks

Enumerations
enum	{ magicNumber =0x6d736100 , currentVersion =1 }
enum class	SectionType : U8 {   unknown = 0 , user = 0 , type = 1 , import = 2 ,   functionDeclarations = 3 , table = 4 , memory = 5 , global = 6 ,   export_ = 7 , start = 8 , elem = 9 , functionDefinitions = 10 ,   data = 11 }

Functions
WEBASSEMBLY_API void	serialize (Serialization::InputStream &stream, IR::Module &module)
WEBASSEMBLY_API void	serialize (Serialization::OutputStream &stream, const IR::Module &module)
FORCEINLINE void	serialize (InputStream &stream, Opcode &opcode)
FORCEINLINE void	serialize (OutputStream &stream, Opcode opcode)
template<typename Stream >
void	serialize (Stream &stream, NoImm &, const FunctionDef &)
template<typename Stream >
void	serialize (Stream &stream, ControlStructureImm &imm, const FunctionDef &)
template<typename Stream >
void	serialize (Stream &stream, BranchImm &imm, const FunctionDef &)
void	serialize (InputStream &stream, BranchTableImm &imm, FunctionDef &functionDef)
void	serialize (OutputStream &stream, BranchTableImm &imm, FunctionDef &functionDef)
template<typename Stream >
void	serialize (Stream &stream, LiteralImm< I32 > &imm, const FunctionDef &)
template<typename Stream >
void	serialize (Stream &stream, LiteralImm< I64 > &imm, const FunctionDef &)
template<typename Stream , bool isGlobal>
void	serialize (Stream &stream, GetOrSetVariableImm< isGlobal > &imm, const FunctionDef &)
template<typename Stream >
void	serialize (Stream &stream, CallImm &imm, const FunctionDef &)
template<typename Stream >
void	serialize (Stream &stream, CallIndirectImm &imm, const FunctionDef &)
template<typename Stream , Uptr naturalAlignmentLog2>
void	serialize (Stream &stream, LoadOrStoreImm< naturalAlignmentLog2 > &imm, const FunctionDef &)
template<typename Stream >
void	serialize (Stream &stream, MemoryImm &imm, const FunctionDef &)
template<typename Stream , typename Value >
void	serialize (Stream &stream, LiteralImm< Value > &imm, const FunctionDef &)
template<typename SerializeSection >
void	serializeSection (OutputStream &stream, SectionType type, SerializeSection serializeSectionBody)
template<typename SerializeSection >
void	serializeSection (InputStream &stream, SectionType expectedType, SerializeSection serializeSectionBody)
void	serialize (OutputStream &stream, UserSection &userSection)
void	serialize (InputStream &stream, UserSection &userSection)
template<typename Stream >
void	serialize (Stream &stream, LocalSet &localSet)
void	serializeFunctionBody (OutputStream &sectionStream, Module &module, FunctionDef &functionDef)
void	serializeFunctionBody (InputStream &sectionStream, Module &module, FunctionDef &functionDef)
template<typename Stream >
void	serializeTypeSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeImportSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeFunctionSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeTableSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeMemorySection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeGlobalSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeExportSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeStartSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeElementSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeCodeSection (Stream &moduleStream, Module &module)
template<typename Stream >
void	serializeDataSection (Stream &moduleStream, Module &module)
void	serializeModule (OutputStream &moduleStream, Module &module)
void	serializeModule (InputStream &moduleStream, Module &module)

Variables
bool	check_limits = true

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
magicNumber
currentVersion

Definition at line 185 of file WASMSerialization.cpp.

    {
        magicNumber=0x6d736100, // "\0asm"
        currentVersion=1
    };

SectionType

enum class WASM::SectionType : U8

strong

Enumerator
unknown
user
type
import
functionDeclarations
table
memory
global
export_
start
elem
functionDefinitions
data

Definition at line 191 of file WASMSerialization.cpp.

    {
        unknown = 0,
        user = 0,
        type = 1,
        import = 2,
        functionDeclarations = 3,
        table = 4,
        memory = 5,
        global = 6,
        export_ = 7,
        start = 8,
        elem = 9,
        functionDefinitions = 10,
        data = 11
    };

Function Documentation

serialize() [1/20]

void WASM::serialize	(	InputStream &	stream,
		BranchTableImm &	imm,
		FunctionDef &	functionDef )

Definition at line 245 of file WASMSerialization.cpp.

    {
        std::vector<U32> branchTable;
        serializeArray(stream,branchTable,[](InputStream& stream,U32& targetDepth){serializeVarUInt32(stream,targetDepth);});
        imm.branchTableIndex = functionDef.branchTables.size();
        functionDef.branchTables.push_back(std::move(branchTable));
        serializeVarUInt32(stream,imm.defaultTargetDepth);
    }

Here is the call graph for this function:

serialize() [2/20]

FORCEINLINE void WASM::serialize	(	InputStream &	stream,
		Opcode &	opcode )

Definition at line 208 of file WASMSerialization.cpp.

    {
        opcode = (Opcode)0;
        Serialization::serializeNativeValue(stream,*(U8*)&opcode);
        if(opcode > Opcode::maxSingleByteOpcode)
        {
            opcode = (Opcode)(U16(opcode) << 8);
            Serialization::serializeNativeValue(stream,*(U8*)&opcode);
        }
    }

Here is the call graph for this function:

serialize() [3/20]

void WASM::serialize	(	InputStream &	stream,
		UserSection &	userSection )

Definition at line 393 of file WASMSerialization.cpp.

    {
        serializeConstant(stream,"expected user section (section ID 0)",(U8)SectionType::user);
        Uptr numSectionBytes = 0;
        serializeVarUInt32(stream,numSectionBytes);
        
        MemoryInputStream sectionStream(stream.advance(numSectionBytes),numSectionBytes);
        serialize(sectionStream,userSection.name);
        throwIfNotValidUTF8(userSection.name);
        userSection.data.resize(sectionStream.capacity());
        serializeBytes(sectionStream,userSection.data.data(),userSection.data.size());
        WAVM_ASSERT_THROW(!sectionStream.capacity());
    }

Here is the call graph for this function:

serialize() [4/20]

void WASM::serialize	(	OutputStream &	stream,
		BranchTableImm &	imm,
		FunctionDef &	functionDef )

Definition at line 253 of file WASMSerialization.cpp.

    {
        WAVM_ASSERT_THROW(imm.branchTableIndex < functionDef.branchTables.size());
        std::vector<U32>& branchTable = functionDef.branchTables[imm.branchTableIndex];
        serializeArray(stream,branchTable,[](OutputStream& stream,U32& targetDepth){serializeVarUInt32(stream,targetDepth);});
        serializeVarUInt32(stream,imm.defaultTargetDepth);
    }

Here is the call graph for this function:

serialize() [5/20]

FORCEINLINE void WASM::serialize	(	OutputStream &	stream,
		Opcode	opcode )

Definition at line 218 of file WASMSerialization.cpp.

    {
        if(opcode <= Opcode::maxSingleByteOpcode) { Serialization::serializeNativeValue(stream,*(U8*)&opcode); }
        else
        {
            serializeNativeValue(stream,*(((U8*)&opcode) + 1));
            serializeNativeValue(stream,*(((U8*)&opcode) + 0));
        }
    }

Here is the call graph for this function:

serialize() [6/20]

void WASM::serialize	(	OutputStream &	stream,
		UserSection &	userSection )

Definition at line 381 of file WASMSerialization.cpp.

    {
        serializeConstant(stream,"expected user section (section ID 0)",(U8)SectionType::user);
        ArrayOutputStream sectionStream;
        serialize(sectionStream,userSection.name);
        userSection.data.resize( sectionStream.capacity() ? sectionStream.capacity() : 1 );
        serializeBytes(sectionStream,userSection.data.data(),userSection.data.size());
        std::vector<U8> sectionBytes = sectionStream.getBytes();
        serialize(stream,sectionBytes);
        if( !sectionStream.capacity() ) throw FatalSerializationException( "empty section" );
    }

Here is the call graph for this function:

serialize() [7/20]

void WASM::serialize	(	Serialization::InputStream &	stream,
		IR::Module &	module )

Definition at line 841 of file WASMSerialization.cpp.

    {
        serializeModule(stream,module);
        IR::validateDefinitions(module);
    }

Here is the call graph for this function:

serialize() [8/20]

void WASM::serialize	(	Serialization::OutputStream &	stream,
		const IR::Module &	module )

Definition at line 846 of file WASMSerialization.cpp.

    {
        serializeModule(stream,const_cast<Module&>(module));
    }

Here is the call graph for this function:

serialize() [9/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		BranchImm &	imm,
		const FunctionDef &	)

Definition at line 240 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,imm.targetDepth);
    }

Here is the call graph for this function:

serialize() [10/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		CallImm &	imm,
		const FunctionDef &	)

Definition at line 274 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,imm.functionIndex);
    }

Here is the call graph for this function:

serialize() [11/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		CallIndirectImm &	imm,
		const FunctionDef &	)

Definition at line 280 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,imm.type.index);
        serializeConstant(stream,"call_indirect immediate reserved field must be 0",U8(0));
    }

Here is the call graph for this function:

serialize() [12/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		ControlStructureImm &	imm,
		const FunctionDef &	)

Definition at line 232 of file WASMSerialization.cpp.

    {
        I8 encodedResultType = imm.resultType == ResultType::none ? -64 : -(I8)imm.resultType;
        serializeVarInt7(stream,encodedResultType);
        if(Stream::isInput) { imm.resultType = encodedResultType == -64 ? ResultType::none : (ResultType)-encodedResultType; }
    }

Here is the call graph for this function:

serialize() [13/20]

template<typename Stream , bool isGlobal>

void WASM::serialize	(	Stream &	stream,
		GetOrSetVariableImm< isGlobal > &	imm,
		const FunctionDef &	)

Definition at line 270 of file WASMSerialization.cpp.

    { serializeVarUInt32(stream,imm.variableIndex); }

Here is the call graph for this function:

serialize() [14/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		LiteralImm< I32 > &	imm,
		const FunctionDef &	)

Definition at line 262 of file WASMSerialization.cpp.

    { serializeVarInt32(stream,imm.value); }

Here is the call graph for this function:

serialize() [15/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		LiteralImm< I64 > &	imm,
		const FunctionDef &	)

Definition at line 266 of file WASMSerialization.cpp.

    { serializeVarInt64(stream,imm.value); }

Here is the call graph for this function:

serialize() [16/20]

template<typename Stream , typename Value >

void WASM::serialize	(	Stream &	stream,
		LiteralImm< Value > &	imm,
		const FunctionDef &	)

Definition at line 355 of file WASMSerialization.cpp.

    { serialize(stream,imm.value); }

Here is the call graph for this function:

serialize() [17/20]

template<typename Stream , Uptr naturalAlignmentLog2>

void WASM::serialize	(	Stream &	stream,
		LoadOrStoreImm< naturalAlignmentLog2 > &	imm,
		const FunctionDef &	)

Definition at line 287 of file WASMSerialization.cpp.

    {
        serializeVarUInt7(stream,imm.alignmentLog2);
        serializeVarUInt32(stream,imm.offset);
    }

Here is the call graph for this function:

serialize() [18/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		LocalSet &	localSet )

Definition at line 414 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,localSet.num);
        serialize(stream,localSet.type);
    }

Here is the call graph for this function:

serialize() [19/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		MemoryImm &	imm,
		const FunctionDef &	)

Definition at line 293 of file WASMSerialization.cpp.

    {
        serializeConstant(stream,"grow_memory/current_memory immediate reserved field must be 0",U8(0));
    }

Here is the call graph for this function:

serialize() [20/20]

template<typename Stream >

void WASM::serialize	(	Stream &	stream,
		NoImm &	,
		const FunctionDef &	)

Definition at line 229 of file WASMSerialization.cpp.

{}

serializeCodeSection()

template<typename Stream >

void WASM::serializeCodeSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 760 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::functionDefinitions,[&module](Stream& sectionStream)
        {
            Uptr numFunctionBodies = module.functions.defs.size();
            serializeVarUInt32(sectionStream,numFunctionBodies);
            if(Stream::isInput && numFunctionBodies != module.functions.defs.size())
                { throw FatalSerializationException("function and code sections have mismatched function counts"); }
            for(FunctionDef& functionDef : module.functions.defs) { serializeFunctionBody(sectionStream,module,functionDef); }
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeDataSection()

template<typename Stream >

void WASM::serializeDataSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 773 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::data,[&module](Stream& sectionStream)
        {
            serialize(sectionStream,module.dataSegments);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeElementSection()

template<typename Stream >

void WASM::serializeElementSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 751 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::elem,[&module](Stream& sectionStream)
        {
            serialize(sectionStream,module.tableSegments);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeExportSection()

template<typename Stream >

void WASM::serializeExportSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 733 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::export_,[&module](Stream& sectionStream)
        {
            serialize(sectionStream,module.exports);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeFunctionBody() [1/2]

void WASM::serializeFunctionBody	(	InputStream &	sectionStream,
		Module &	module,
		FunctionDef &	functionDef )

Definition at line 483 of file WASMSerialization.cpp.

    {
        Uptr numBodyBytes = 0;
        serializeVarUInt32(sectionStream,numBodyBytes);
 
        MemoryInputStream bodyStream(sectionStream.advance(numBodyBytes),numBodyBytes);
        
        // Deserialize local sets and unpack them into a linear array of local types.
        Uptr numLocalSets = 0;
        serializeVarUInt32(bodyStream,numLocalSets);
 
        constexpr size_t max_size = sysio::chain::wasm_constraints::maximum_code_size;
        if (numBodyBytes >= max_size && WASM::check_limits)
            throw FatalSerializationException(std::string("Function body too large"));
        if (numLocalSets >= 1024 && WASM::check_limits)
            throw FatalSerializationException(std::string("too many local sets"));
        size_t locals_accum = 0;
 
        for(Uptr setIndex = 0;setIndex < numLocalSets;++setIndex)
        {
            LocalSet localSet;
            serialize(bodyStream,localSet);
            locals_accum += localSet.num*4;
            if( locals_accum > sysio::chain::wasm_constraints::maximum_func_local_bytes && WASM::check_limits )
                throw FatalSerializationException( "too many locals" );
 
            for(Uptr index = 0;index < localSet.num;++index) { functionDef.nonParameterLocalTypes.push_back(localSet.type); }
        }
 
        // Deserialize the function code, validate it, and re-encode it in the IR format.
        ArrayOutputStream irCodeByteStream;
        OperatorEncoderStream irEncoderStream(irCodeByteStream);
        CodeValidationStream codeValidationStream(module,functionDef);
        while(bodyStream.capacity())
        {
            Opcode opcode;
            serialize(bodyStream,opcode);
            switch(opcode)
            {
            #define VISIT_OPCODE(_,name,nameString,Imm,...) \
                case Opcode::name: \
                { \
                    Imm imm; \
                    serialize(bodyStream,imm,functionDef); \
                    codeValidationStream.name(imm); \
                    irEncoderStream.name(imm); \
                    break; \
                }
            ENUM_OPERATORS(VISIT_OPCODE)
            #undef VISIT_OPCODE
            default: throw FatalSerializationException("unknown opcode");
            };
        };
        codeValidationStream.finish();
        functionDef.code = std::move(irCodeByteStream.getBytes());
    }

Here is the call graph for this function:

serializeFunctionBody() [2/2]

void WASM::serializeFunctionBody	(	OutputStream &	sectionStream,
		Module &	module,
		FunctionDef &	functionDef )

Definition at line 446 of file WASMSerialization.cpp.

    {
        ArrayOutputStream bodyStream;
 
        // Convert the function's local types into LocalSets: runs of locals of the same type.
        LocalSet* localSets = (LocalSet*)alloca(sizeof(LocalSet)*functionDef.nonParameterLocalTypes.size());
        Uptr numLocalSets = 0;
        if(functionDef.nonParameterLocalTypes.size())
        {
            localSets[0].type = ValueType::any;
            localSets[0].num = 0;
            for(auto localType : functionDef.nonParameterLocalTypes)
            {
                if(localSets[numLocalSets].type != localType)
                {
                    if(localSets[numLocalSets].type != ValueType::any) { ++numLocalSets; }
                    localSets[numLocalSets].type = localType;
                    localSets[numLocalSets].num = 0;
                }
                ++localSets[numLocalSets].num;
            }
            if(localSets[numLocalSets].type != ValueType::any) { ++numLocalSets; }
        }
 
        // Serialize the local sets.
        serializeVarUInt32(bodyStream,numLocalSets);
        for(Uptr setIndex = 0;setIndex < numLocalSets;++setIndex) { serialize(bodyStream,localSets[setIndex]); }
 
        // Serialize the function code.
        OperatorDecoderStream irDecoderStream(functionDef.code);
        OperatorSerializerStream wasmOpEncoderStream(bodyStream,functionDef);
        while(irDecoderStream) { irDecoderStream.decodeOp(wasmOpEncoderStream); };
 
        std::vector<U8> bodyBytes = bodyStream.getBytes();
        serialize(sectionStream,bodyBytes);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeFunctionSection()

template<typename Stream >

void WASM::serializeFunctionSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 672 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::functionDeclarations,[&module](Stream& sectionStream)
        {
            Uptr numFunctions = module.functions.defs.size();
            serializeVarUInt32(sectionStream,numFunctions);
            if(Stream::isInput)
            {
                // Grow the vector one element at a time:
                // try to get a serialization exception before making a huge allocation for malformed input.
                module.functions.defs.clear();
                constexpr size_t max_size = sysio::chain::wasm_constraints::maximum_section_elements;
                if ( numFunctions >= max_size && WASM::check_limits )
                    throw FatalSerializationException(std::string("Too many function defs"));
                for(Uptr functionIndex = 0;functionIndex < numFunctions;++functionIndex)
                {
                    U32 functionTypeIndex = 0;
                    serializeVarUInt32(sectionStream,functionTypeIndex);
                    if(functionTypeIndex >= module.types.size()) { throw FatalSerializationException("invalid function type index"); }
                    module.functions.defs.push_back({{functionTypeIndex},{},{}});
                }
                module.functions.defs.shrink_to_fit();
            }
            else
            {
                for(FunctionDef& function : module.functions.defs)
                {
                    serializeVarUInt32(sectionStream,function.type.index);
                }
            }
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeGlobalSection()

template<typename Stream >

void WASM::serializeGlobalSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 724 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::global,[&module](Stream& sectionStream)
        {
            serialize(sectionStream,module.globals.defs);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeImportSection()

template<typename Stream >

void WASM::serializeImportSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 565 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::import,[&module](Stream& sectionStream)
        {
            Uptr size = module.functions.imports.size()
                + module.tables.imports.size()
                + module.memories.imports.size()
                + module.globals.imports.size();
            serializeVarUInt32(sectionStream,size);
            constexpr size_t max_size = sysio::chain::wasm_constraints::maximum_section_elements;
            if(Stream::isInput)
            {
                for(Uptr index = 0;index < size;++index)
                {
                    std::string moduleName;
                    std::string exportName;
                    ObjectKind kind = ObjectKind::invalid;
                    serialize(sectionStream,moduleName);
                    serialize(sectionStream,exportName);
                    throwIfNotValidUTF8(moduleName);
                    throwIfNotValidUTF8(exportName);
                    serialize(sectionStream,kind);
                    switch(kind)
                    {
                    case ObjectKind::function:
                    {
                        U32 functionTypeIndex = 0;
                        serializeVarUInt32(sectionStream,functionTypeIndex);
                        if(functionTypeIndex >= module.types.size())
                        {
                            throw FatalSerializationException("invalid import function type index");
                        }
                        module.functions.imports.push_back({{functionTypeIndex},std::move(moduleName),std::move(exportName)});
                        if (module.functions.imports.size() >= max_size && WASM::check_limits)
                            throw FatalSerializationException(std::string("Too many function imports"));
                        break;
                    }
                    case ObjectKind::table:
                    {
                        TableType tableType;
                        serialize(sectionStream,tableType);
                        module.tables.imports.push_back({tableType,std::move(moduleName),std::move(exportName)});
                        if (module.functions.imports.size() >= max_size && WASM::check_limits)
                            throw FatalSerializationException(std::string("Too many table imports"));
                        break;
                    }
                    case ObjectKind::memory:
                    {
                        MemoryType memoryType;
                        serialize(sectionStream,memoryType);
                        module.memories.imports.push_back({memoryType,std::move(moduleName),std::move(exportName)});
                        if (module.functions.imports.size() >= max_size && WASM::check_limits)
                            throw FatalSerializationException(std::string("Too many memory imports"));
                        break;
                    }
                    case ObjectKind::global:
                    {
                        GlobalType globalType;
                        serialize(sectionStream,globalType);
                        module.globals.imports.push_back({globalType,std::move(moduleName),std::move(exportName)});
                        if (module.functions.imports.size() >= max_size && WASM::check_limits)
                            throw FatalSerializationException(std::string("Too many global imports"));
                        break;
                    }
                    default: throw FatalSerializationException("invalid ObjectKind");
                    }
                }
            }
            else
            {
                for(auto& functionImport : module.functions.imports)
                {
                    serialize(sectionStream,functionImport.moduleName);
                    serialize(sectionStream,functionImport.exportName);
                    ObjectKind kind = ObjectKind::function;
                    serialize(sectionStream,kind);
                    serializeVarUInt32(sectionStream,functionImport.type.index);
                }
                for(auto& tableImport : module.tables.imports)
                {
                    serialize(sectionStream,tableImport.moduleName);
                    serialize(sectionStream,tableImport.exportName);
                    ObjectKind kind = ObjectKind::table;
                    serialize(sectionStream,kind);
                    serialize(sectionStream,tableImport.type);
                }
                for(auto& memoryImport : module.memories.imports)
                {
                    serialize(sectionStream,memoryImport.moduleName);
                    serialize(sectionStream,memoryImport.exportName);
                    ObjectKind kind = ObjectKind::memory;
                    serialize(sectionStream,kind);
                    serialize(sectionStream,memoryImport.type);
                }
                for(auto& globalImport : module.globals.imports)
                {
                    serialize(sectionStream,globalImport.moduleName);
                    serialize(sectionStream,globalImport.exportName);
                    ObjectKind kind = ObjectKind::global;
                    serialize(sectionStream,kind);
                    serialize(sectionStream,globalImport.type);
                }
            }
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeMemorySection()

template<typename Stream >

void WASM::serializeMemorySection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 715 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::memory,[&module](Stream& sectionStream)
        {
            serialize(sectionStream,module.memories.defs);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeModule() [1/2]

void WASM::serializeModule	(	InputStream &	moduleStream,
		Module &	module )

Definition at line 803 of file WASMSerialization.cpp.

    {
        serializeConstant(moduleStream,"magic number",U32(magicNumber));
        serializeConstant(moduleStream,"version",U32(currentVersion));
 
        SectionType lastKnownSectionType = SectionType::unknown;
        while(moduleStream.capacity())
        {
            const SectionType sectionType = *(SectionType*)moduleStream.peek(sizeof(SectionType));
            if(sectionType != SectionType::user)
            {
                if(sectionType > lastKnownSectionType) { lastKnownSectionType = sectionType; }
                else { throw FatalSerializationException("incorrect order for known section"); }
            }
            switch(sectionType)
            {
            case SectionType::type: serializeTypeSection(moduleStream,module); break;
            case SectionType::import: serializeImportSection(moduleStream,module); break;
            case SectionType::functionDeclarations: serializeFunctionSection(moduleStream,module); break;
            case SectionType::table: serializeTableSection(moduleStream,module); break;
            case SectionType::memory: serializeMemorySection(moduleStream,module); break;
            case SectionType::global: serializeGlobalSection(moduleStream,module); break;
            case SectionType::export_: serializeExportSection(moduleStream,module); break;
            case SectionType::start: serializeStartSection(moduleStream,module); break;
            case SectionType::elem: serializeElementSection(moduleStream,module); break;
            case SectionType::functionDefinitions: serializeCodeSection(moduleStream,module); break;
            case SectionType::data: serializeDataSection(moduleStream,module); break;
            case SectionType::user:
            {
                UserSection& userSection = *module.userSections.insert(module.userSections.end(),UserSection());
                serialize(moduleStream,userSection);
                break;
            }
            default: throw FatalSerializationException("unknown section ID");
            };
        };
    }

Here is the call graph for this function:

serializeModule() [2/2]

void WASM::serializeModule	(	OutputStream &	moduleStream,
		Module &	module )

Definition at line 781 of file WASMSerialization.cpp.

    {
        serializeConstant(moduleStream,"magic number",U32(magicNumber));
        serializeConstant(moduleStream,"version",U32(currentVersion));
 
        if(module.types.size() > 0) { serializeTypeSection(moduleStream,module); }
        if(module.functions.imports.size() > 0
        || module.tables.imports.size() > 0
        || module.memories.imports.size() > 0
        || module.globals.imports.size() > 0) { serializeImportSection(moduleStream,module); }
        if(module.functions.defs.size() > 0) { serializeFunctionSection(moduleStream,module); }
        if(module.tables.defs.size() > 0) { serializeTableSection(moduleStream,module); }
        if(module.memories.defs.size() > 0) { serializeMemorySection(moduleStream,module); }
        if(module.globals.defs.size() > 0) { serializeGlobalSection(moduleStream,module); }
        if(module.exports.size() > 0) { serializeExportSection(moduleStream,module); }
        if(module.startFunctionIndex != UINTPTR_MAX) { serializeStartSection(moduleStream,module); }
        if(module.tableSegments.size() > 0) { serializeElementSection(moduleStream,module); }
        if(module.functions.defs.size() > 0) { serializeCodeSection(moduleStream,module); }
        if(module.dataSegments.size() > 0) { serializeDataSection(moduleStream,module); }
 
        for(auto& userSection : module.userSections) { serialize(moduleStream,userSection); }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeSection() [1/2]

template<typename SerializeSection >

void WASM::serializeSection	(	InputStream &	stream,
		SectionType	expectedType,
		SerializeSection	serializeSectionBody )

Definition at line 370 of file WASMSerialization.cpp.

    {
        WAVM_ASSERT_THROW((SectionType)*stream.peek(sizeof(SectionType)) == expectedType);
        stream.advance(sizeof(SectionType));
        Uptr numSectionBytes = 0;
        serializeVarUInt32(stream,numSectionBytes);
        MemoryInputStream sectionStream(stream.advance(numSectionBytes),numSectionBytes);
        serializeSectionBody(sectionStream);
        if(sectionStream.capacity()) { throw FatalSerializationException("section contained more data than expected"); }
    }

Here is the call graph for this function:

serializeSection() [2/2]

template<typename SerializeSection >

void WASM::serializeSection	(	OutputStream &	stream,
		SectionType	type,
		SerializeSection	serializeSectionBody )

Definition at line 359 of file WASMSerialization.cpp.

    {
        serializeNativeValue(stream,type);
        ArrayOutputStream sectionStream;
        serializeSectionBody(sectionStream);
        std::vector<U8> sectionBytes = sectionStream.getBytes();
        Uptr sectionNumBytes = sectionBytes.size();
        serializeVarUInt32(stream,sectionNumBytes);
        serializeBytes(stream,sectionBytes.data(),sectionBytes.size());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeStartSection()

template<typename Stream >

void WASM::serializeStartSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 742 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::start,[&module](Stream& sectionStream)
        {
            serializeVarUInt32(sectionStream,module.startFunctionIndex);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeTableSection()

template<typename Stream >

void WASM::serializeTableSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 706 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::table,[&module](Stream& sectionStream)
        {
            serialize(sectionStream,module.tables.defs);
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeTypeSection()

template<typename Stream >

void WASM::serializeTypeSection	(	Stream &	moduleStream,
		Module &	module )

Definition at line 541 of file WASMSerialization.cpp.

    {
        serializeSection(moduleStream,SectionType::type,[&module](Stream& sectionStream)
        {
            serializeArray(sectionStream,module.types,[](Stream& stream,const FunctionType*& functionType)
            {
                serializeConstant(stream,"function type tag",U8(0x60));
                if(Stream::isInput)
                {
                    std::vector<ValueType> parameterTypes;
                    ResultType returnType;
                    serialize(stream,parameterTypes);
                    serialize(stream,returnType);
                    functionType = FunctionType::get(returnType,parameterTypes);
                }
                else
                {
                    serialize(stream,const_cast<std::vector<ValueType>&>(functionType->parameters));
                    serialize(stream,const_cast<ResultType&>(functionType->ret));
                }
            });
        });
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

check_limits

bool WASM::check_limits = true

Definition at line 14 of file WASM.h.