IR Namespace Reference

Classes
struct	BranchImm
struct	BranchTableImm
struct	CallImm
struct	CallIndirectImm
struct	CodeValidationProxyStream
struct	CodeValidationStream
struct	CodeValidationStreamImpl
struct	ControlStructureImm
struct	DataSegment
struct	DisassemblyNames
struct	Export
struct	FromResultType
struct	FromResultType< ResultType::f32 >
struct	FromResultType< ResultType::f64 >
struct	FromResultType< ResultType::i32 >
struct	FromResultType< ResultType::i64 >
struct	FromResultType< ResultType::none >
struct	FromValueType
struct	FromValueType< ValueType::any >
struct	FromValueType< ValueType::f32 >
struct	FromValueType< ValueType::f64 >
struct	FromValueType< ValueType::i32 >
struct	FromValueType< ValueType::i64 >
struct	FunctionDef
struct	FunctionType
struct	FunctionTypeMap
struct	FunctionValidationContext
struct	GetOrSetVariableImm
struct	GlobalDef
struct	GlobalType
struct	Import
struct	IndexedFunctionType
struct	IndexSpace
struct	InitializerExpression
struct	LiteralImm
struct	LoadOrStoreImm
struct	MemoryDef
struct	MemoryImm
struct	MemoryType
struct	Module
struct	NoImm
struct	ObjectType
struct	OpcodeAndImm< MemoryImm >
struct	OpcodeAndImm< NoImm >
struct	OperatorDecoderStream
struct	OperatorEncoderStream
struct	OperatorPrinter
struct	SizeConstraints
struct	TableDef
struct	TableSegment
struct	TableType
struct	ToResultType
struct	ToResultType< 0 >
struct	ToResultType< 1 >
struct	ToResultType< 2 >
struct	ToResultType< 3 >
struct	ToResultType< 4 >
struct	ToValueType
struct	ToValueType< 0 >
struct	ToValueType< 1 >
struct	ToValueType< 2 >
struct	ToValueType< 3 >
struct	ToValueType< 4 >
struct	UserSection
struct	ValidationException
struct	ValueTypeInfo
struct	ValueTypeInfo< ValueType::f32 >
struct	ValueTypeInfo< ValueType::f64 >
struct	ValueTypeInfo< ValueType::i32 >
struct	ValueTypeInfo< ValueType::i64 >

Typedefs
typedef Import< Uptr >	FunctionImport
typedef Import< TableType >	TableImport
typedef Import< MemoryType >	MemoryImport
typedef Import< GlobalType >	GlobalImport

Enumerations
enum	{ maxMemoryPages = (Uptr)65536 }
enum	{ numBytesPerPage = (Uptr)65536 }
enum	{ numBytesPerPageLog2 = (Uptr)16 }
enum	{ requireSharedFlagForAtomicOperators = false }
enum class	Opcode : U16 { VISIT_OPCODE , maxSingleByteOpcode = 0xcf }
enum class	ValueType : U8 {   any = 0 , i32 = 1 , i64 = 2 , f32 = 3 ,   f64 = 4 , num , max = num-1 }
enum class	ResultType : U8 {   none = 0 , i32 = (U8)ValueType::i32 , i64 = (U8)ValueType::i64 , f32 = (U8)ValueType::f32 ,   f64 = (U8)ValueType::f64 , num , max = num-1 }
enum class	TableElementType : U8 { anyfunc = 0x70 }
enum class	ObjectKind : U8 {   function = 0 , table = 1 , memory = 2 , global = 3 ,   module = 4 , max = 4 , invalid = 0xff }

Functions
bool	findUserSection (const Module &module, const char *userSectionName, Uptr &outUserSectionIndex)
IR_API void	getDisassemblyNames (const Module &module, DisassemblyNames &outNames)
IR_API void	setDisassemblyNames (Module &module, const DisassemblyNames &names)
	PACKED_STRUCT (template< typename Imm > struct OpcodeAndImm { Opcode opcode;Imm imm;})
IR_API const char *	getOpcodeName (Opcode opcode)
std::string	asString (I32 value)
std::string	asString (I64 value)
std::string	asString (F32 value)
std::string	asString (F64 value)
U8	getTypeBitWidth (ValueType type)
const char *	asString (ValueType type)
Uptr	getArity (ResultType returnType)
const char *	asString (ResultType type)
ValueType	asValueType (ResultType type)
ResultType	asResultType (ValueType type)
std::string	asString (const std::vector< ValueType > &typeTuple)
std::string	asString (const FunctionType *functionType)
std::string	asString (const GlobalType &globalType)
std::string	asString (const ObjectType &objectType)
IR_API void	validateDefinitions (const IR::Module &module)
template<typename Key , typename Value , typename CreateValueThunk >
Value	findExistingOrCreateNew (std::map< Key, Value > &map, Key &&key, CreateValueThunk createValueThunk)
void	validate (ValueType valueType)
void	validate (ResultType returnType)
void	validate (ObjectKind kind)
void	validate (SizeConstraints size, Uptr maxMax)
void	validate (TableElementType type)
void	validate (TableType type)
void	validate (MemoryType type)
void	validate (GlobalType type)
void	validateImportKind (ObjectType importType, ObjectKind expectedKind)
template<typename Type >
void	validateType (Type expectedType, Type actualType, const char *context)
void	validateOperandType (ValueType expectedType, ValueType actualType, const char *context)
ValueType	validateGlobalIndex (const Module &module, Uptr globalIndex, bool mustBeMutable, bool mustBeImmutable, bool mustBeImport, const char *context)
const FunctionType *	validateFunctionIndex (const Module &module, Uptr functionIndex)
void	validateInitializer (const Module &module, const InitializerExpression &expression, ValueType expectedType, const char *context)
template<typename Stream >
void	serialize (Stream &stream, ValueType &type)
template<typename Stream >
void	serialize (Stream &stream, SizeConstraints &sizeConstraints, bool hasMax)
template<typename Stream >
void	serialize (Stream &stream, TableElementType &elementType)
template<typename Stream >
void	serialize (Stream &stream, TableType &tableType)
template<typename Stream >
void	serialize (Stream &stream, MemoryType &memoryType)
template<typename Stream >
void	serialize (Stream &stream, GlobalType &globalType)
template<typename Stream >
void	serialize (Stream &stream, ObjectKind &kind)
template<typename Stream >
void	serialize (Stream &stream, Export &e)
template<typename Stream >
void	serialize (Stream &stream, InitializerExpression &initializer)
template<typename Stream >
void	serialize (Stream &stream, TableDef &tableDef)
template<typename Stream >
void	serialize (Stream &stream, MemoryDef &memoryDef)
template<typename Stream >
void	serialize (Stream &stream, GlobalDef &globalDef)
template<typename Stream >
void	serialize (Stream &stream, DataSegment &dataSegment)
template<typename Stream >
void	serialize (Stream &stream, TableSegment &tableSegment)

Typedef Documentation

FunctionImport

typedef Import<Uptr> IR::FunctionImport

Definition at line 77 of file Module.h.

GlobalImport

typedef Import<GlobalType> IR::GlobalImport

Definition at line 80 of file Module.h.

MemoryImport

typedef Import<MemoryType> IR::MemoryImport

Definition at line 79 of file Module.h.

TableImport

typedef Import<TableType> IR::TableImport

Definition at line 78 of file Module.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
maxMemoryPages

Definition at line 11 of file IR.h.

{ maxMemoryPages = (Uptr)65536 };

anonymous enum

anonymous enum

Enumerator
numBytesPerPage

Definition at line 12 of file IR.h.

{ numBytesPerPage = (Uptr)65536 };

anonymous enum

anonymous enum

Enumerator
numBytesPerPageLog2

Definition at line 13 of file IR.h.

{ numBytesPerPageLog2 = (Uptr)16 };

anonymous enum

anonymous enum

Enumerator
requireSharedFlagForAtomicOperators

Definition at line 15 of file IR.h.

{ requireSharedFlagForAtomicOperators = false };

ObjectKind

enum class IR::ObjectKind : U8

strong

Enumerator
function
table
memory
global
module
max
invalid

Definition at line 306 of file Types.h.

    {
        function = 0,
        table = 1,
        memory = 2,
        global = 3,
        module = 4,
        max = 4,
        invalid = 0xff,
    };

Opcode

enum class IR::Opcode : U16

strong

Enumerator
VISIT_OPCODE
maxSingleByteOpcode

Definition at line 575 of file Operators.h.

    {
        #define VISIT_OPCODE(opcode,name,...) name = opcode,
        ENUM_OPERATORS(VISIT_OPCODE)
        #undef VISIT_OPCODE
 
        maxSingleByteOpcode = 0xcf,
    };

ResultType

enum class IR::ResultType : U8

strong

Enumerator
none
i32
i64
f32
f64
num
max

Definition at line 133 of file Types.h.

    {
        none = 0,
        i32 = (U8)ValueType::i32,
        i64 = (U8)ValueType::i64,
        f32 = (U8)ValueType::f32,
        f64 = (U8)ValueType::f64,
        #if ENABLE_SIMD_PROTOTYPE
        v128 = (U8)ValueType::v128,
        #endif
        num,
        max = num-1,
    };

TableElementType

enum class IR::TableElementType : U8

strong

Enumerator
anyfunc

Definition at line 246 of file Types.h.

    {
        anyfunc = 0x70
    };

ValueType

enum class IR::ValueType : U8

strong

Enumerator
any
i32
i64
f32
f64
num
max

Definition at line 13 of file Types.h.

    {
        any = 0,
        i32 = 1,
        i64 = 2,
        f32 = 3,
        f64 = 4,
 
    #if ENABLE_SIMD_PROTOTYPE
        v128 = 5,
    #endif
 
        num,
        max = num-1
    };

Function Documentation

asResultType()

ResultType IR::asResultType ( ValueType type )

inline

Definition at line 186 of file Types.h.

    {
        WAVM_ASSERT_THROW(type != ValueType::any);
        return (ResultType)type;
    }

Here is the caller graph for this function:

asString() [1/10]

std::string IR::asString ( const FunctionType * functionType )

inline

Definition at line 225 of file Types.h.

    {
        return asString(functionType->parameters) + "->" + asString(functionType->ret);
    }

Here is the call graph for this function:

asString() [2/10]

std::string IR::asString ( const GlobalType & globalType )

inline

Definition at line 299 of file Types.h.

    {
        if(globalType.isMutable) { return std::string("global ") + asString(globalType.valueType); }
        else { return std::string("immutable ") + asString(globalType.valueType); }
    }

Here is the call graph for this function:

asString() [3/10]

std::string IR::asString ( const ObjectType & objectType )

inline

Definition at line 358 of file Types.h.

    {
        switch(objectType.kind)
        {
        case ObjectKind::function: return "func " + asString(asFunctionType(objectType));
        case ObjectKind::table: return "table";
        case ObjectKind::memory: return "memory";
        case ObjectKind::global: return asString(asGlobalType(objectType));
        default: Errors::unreachable();
        };
    }

Here is the call graph for this function:

asString() [4/10]

std::string IR::asString ( const std::vector< ValueType > & typeTuple )

inline

Definition at line 213 of file Types.h.

    {
        std::string result = "(";
        for(Uptr parameterIndex = 0;parameterIndex < typeTuple.size();++parameterIndex)
        {
            if(parameterIndex != 0) { result += ','; }
            result += asString(typeTuple[parameterIndex]);
        }
        result += ")";
        return result;
    }

Here is the call graph for this function:

asString() [5/10]

std::string IR::asString ( F32 value )

inline

Definition at line 52 of file Types.h.

{ return std::to_string(value); }

asString() [6/10]

std::string IR::asString ( F64 value )

inline

Definition at line 53 of file Types.h.

{ return std::to_string(value); }

asString() [7/10]

std::string IR::asString ( I32 value )

inline

Definition at line 50 of file Types.h.

{ return std::to_string(value); }

Here is the caller graph for this function:

asString() [8/10]

std::string IR::asString ( I64 value )

inline

Definition at line 51 of file Types.h.

{ return std::to_string(value); }

asString() [9/10]

const char * IR::asString ( ResultType type )

inline

Definition at line 163 of file Types.h.

    {
        switch(type)
        {
        case ResultType::i32: return "i32";
        case ResultType::i64: return "i64";
        case ResultType::f32: return "f32";
        case ResultType::f64: return "f64";
        #if ENABLE_SIMD_PROTOTYPE
        case ResultType::v128: return "v128";
        #endif
        case ResultType::none: return "()";
        default: Errors::unreachable();
        };
    }

Here is the call graph for this function:

asString() [10/10]

const char * IR::asString ( ValueType type )

inline

Definition at line 116 of file Types.h.

    {
        switch(type)
        {
        case ValueType::any: return "any";
        case ValueType::i32: return "i32";
        case ValueType::i64: return "i64";
        case ValueType::f32: return "f32";
        case ValueType::f64: return "f64";
        #if ENABLE_SIMD_PROTOTYPE
        case ValueType::v128: return "v128";
        #endif
        default: Errors::unreachable();
        };
    }

Here is the call graph for this function:

asValueType()

ValueType IR::asValueType ( ResultType type )

inline

Definition at line 180 of file Types.h.

    {
        WAVM_ASSERT_THROW(type != ResultType::none);
        return (ValueType)type;
    }

Here is the caller graph for this function:

findExistingOrCreateNew()

template<typename Key , typename Value , typename CreateValueThunk >

Value IR::findExistingOrCreateNew	(	std::map< Key, Value > &	map,
		Key &&	key,
		CreateValueThunk	createValueThunk )

Definition at line 26 of file Types.cpp.

    {
        auto mapIt = map.find(key);
        if(mapIt != map.end()) { return mapIt->second; }
        else
        {
            Value value = createValueThunk();
            map.insert({std::move(key),value});
            return value;
        }
    }

Here is the caller graph for this function:

findUserSection()

bool IR::findUserSection ( const Module & module, const char * userSectionName, Uptr & outUserSectionIndex )

inline

Definition at line 149 of file Module.h.

    {
        for(Uptr sectionIndex = 0;sectionIndex < module.userSections.size();++sectionIndex)
        {
            if(module.userSections[sectionIndex].name == userSectionName)
            {
                outUserSectionIndex = sectionIndex;
                return true;
            }
        }
        return false;
    }

Here is the caller graph for this function:

getArity()

Uptr IR::getArity ( ResultType returnType )

inline

Definition at line 161 of file Types.h.

{ return returnType == ResultType::none ? 0 : 1; }

getDisassemblyNames()

void IR::getDisassemblyNames	(	const Module &	module,
		DisassemblyNames &	outNames )

Definition at line 11 of file DisassemblyNames.cpp.

    {
        // Fill in the output with the correct number of blank names.
        for(const auto& functionImport : module.functions.imports)
        {
            DisassemblyNames::Function functionNames;
            functionNames.locals.resize(module.types[functionImport.type.index]->parameters.size());
            outNames.functions.push_back(std::move(functionNames));
        }
        for(Uptr functionDefIndex = 0;functionDefIndex < module.functions.defs.size();++functionDefIndex)
        {
            const FunctionDef& functionDef = module.functions.defs[functionDefIndex];
            DisassemblyNames::Function functionNames;
            functionNames.locals.insert(functionNames.locals.begin(),module.types[functionDef.type.index]->parameters.size() + functionDef.nonParameterLocalTypes.size(),"");
            outNames.functions.push_back(std::move(functionNames));
        }
        
        outNames.types.insert(outNames.types.end(),module.types.size(),"");
        outNames.tables.insert(outNames.tables.end(),module.tables.defs.size() + module.tables.imports.size(),"");
        outNames.memories.insert(outNames.memories.end(),module.memories.defs.size() + module.memories.imports.size(),"");
        outNames.globals.insert(outNames.globals.end(),module.globals.defs.size() + module.globals.imports.size(),"");
 
        // Deserialize the name section, if it is present.
        Uptr userSectionIndex = 0;
        if(findUserSection(module,"name",userSectionIndex))
        {
            try
            {
                const UserSection& nameSection = module.userSections[userSectionIndex];
                MemoryInputStream stream(nameSection.data.data(),nameSection.data.size());
            
                #if 0
                while(stream.capacity())
                {
                    U8 substreamType = 0;
                    serializeVarUInt7(stream,substreamType);
 
                    U32 numSubstreamBytes = 0;
                    serializeVarUInt32(stream,numSubstreamBytes);
                    
                    MemoryInputStream substream(stream.advance(numSubstreamBytes),numSubstreamBytes);
                    switch(substreamType)
                    {
                    case 0: // function names
                    {
                        U32 numFunctionNames = 0;
                        serializeVarUInt32(substream,numFunctionNames);
                        for(Uptr functionNameIndex = 0;functionNameIndex < numFunctionNames;++functionNameIndex)
                        {
                            U32 functionIndex = 0;
                            serializeVarUInt32(substream,functionIndex);
 
                            std::string functionName;
                            serialize(substream,functionName);
 
                            if(functionIndex < outNames.functions.size()) { outNames.functions[functionIndex].name = std::move(functionName); }
                        }
                        break;
                    }
                    case 1: // local names
                    {
                        U32 numFunctionLocalNameMaps = 0;
                        serializeVarUInt32(substream,numFunctionLocalNameMaps);
                        for(Uptr functionNameIndex = 0;functionNameIndex < numFunctionLocalNameMaps;++functionNameIndex)
                        {
                            U32 functionIndex = 0;
                            serializeVarUInt32(substream,functionIndex);
 
                            U32 numLocalNames = 0;
                            serializeVarUInt32(substream,numLocalNames);
                            
                            for(Uptr localNameIndex =  0;localNameIndex < numLocalNames;++numLocalNames)
                            {
                                U32 localIndex = 0;
                                serializeVarUInt32(substream,localIndex);
 
                                std::string localName;
                                serialize(substream,localName);
 
                                if(functionIndex < outNames.functions.size() && localIndex < outNames.functions[functionIndex].locals.size())
                                {
                                    outNames.functions[functionIndex].locals[localIndex] = std::move(localName);
                                }
                            }
                        }
 
                        break;
                    }
                    };
                };
                #endif
 
                Uptr numFunctionNames = 0;
                serializeVarUInt32(stream,numFunctionNames);
                numFunctionNames = std::min(numFunctionNames,(Uptr)outNames.functions.size());
 
                for(Uptr functionIndex = 0;functionIndex < numFunctionNames;++functionIndex)
                {
                    DisassemblyNames::Function& functionNames = outNames.functions[functionIndex];
 
                    serialize(stream,outNames.functions[functionIndex].name);
 
                    Uptr numLocalNames = 0;
                    serializeVarUInt32(stream,numLocalNames);
 
                    for(Uptr localIndex = 0;localIndex < numLocalNames;++localIndex)
                    {
                        std::string localName;
                        serialize(stream,localName);
                        if(localIndex < functionNames.locals.size()) { functionNames.locals[localIndex] = std::move(localName); }
                    }
                }
            }
            catch(FatalSerializationException exception)
            {
                Log::printf(Log::Category::debug,"FatalSerializationException while deserializing WASM user name section: %s\n",exception.message.c_str());
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getOpcodeName()

const char * IR::getOpcodeName

(

Opcode

opcode

)

Definition at line 5 of file Operators.cpp.

    {
        switch(opcode)
        {
        #define VISIT_OPCODE(encoding,name,nameString,Imm,...) case Opcode::name: return nameString;
        ENUM_OPERATORS(VISIT_OPCODE)
        #undef VISIT_OPCODE
        default: return "unknown";
        };
    }

getTypeBitWidth()

U8 IR::getTypeBitWidth ( ValueType type )

inline

Definition at line 101 of file Types.h.

    {
        switch(type)
        {
        case ValueType::i32: return 32;
        case ValueType::i64: return 64;
        case ValueType::f32: return 32;
        case ValueType::f64: return 64;
        #if ENABLE_SIMD_PROTOTYPE
        case ValueType::v128: return 128;
        #endif
        default: Errors::unreachable();
        };
    }

Here is the call graph for this function:

Here is the caller graph for this function:

PACKED_STRUCT()

IR::PACKED_STRUCT

(

template< typename Imm > struct OpcodeAndImm { Opcode opcode;Imm imm;}

)

serialize() [1/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		DataSegment &	dataSegment )

Definition at line 162 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,dataSegment.memoryIndex);
        serialize(stream,dataSegment.baseOffset);
        serialize(stream,dataSegment.data);
    }

Here is the call graph for this function:

serialize() [2/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		Export &	e )

Definition at line 118 of file WASMSerialization.cpp.

    {
        serialize(stream,e.name);
        throwIfNotValidUTF8(e.name);
        serialize(stream,e.kind);
        serializeVarUInt32(stream,e.index);
    }

Here is the call graph for this function:

serialize() [3/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		GlobalDef &	globalDef )

Definition at line 155 of file WASMSerialization.cpp.

    {
        serialize(stream,globalDef.type);
        serialize(stream,globalDef.initializer);
    }

Here is the call graph for this function:

serialize() [4/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		GlobalType &	globalType )

Definition at line 103 of file WASMSerialization.cpp.

    {
        serialize(stream,globalType.valueType);
        U8 isMutable = globalType.isMutable ? 1 : 0;
        serializeVarUInt1(stream,isMutable);
        if(Stream::isInput) { globalType.isMutable = isMutable != 0; }
    }

Here is the call graph for this function:

serialize() [5/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		InitializerExpression &	initializer )

Definition at line 127 of file WASMSerialization.cpp.

    {
        serializeNativeValue(stream,*(U8*)&initializer.type);
        switch(initializer.type)
        {
        case InitializerExpression::Type::i32_const: serializeVarInt32(stream,initializer.i32); break;
        case InitializerExpression::Type::i64_const: serializeVarInt64(stream,initializer.i64); break;
        case InitializerExpression::Type::f32_const: serialize(stream,initializer.f32); break;
        case InitializerExpression::Type::f64_const: serialize(stream,initializer.f64); break;
        case InitializerExpression::Type::get_global: serializeVarUInt32(stream,initializer.globalIndex); break;
        default: throw FatalSerializationException("invalid initializer expression opcode");
        }
        serializeConstant(stream,"expected end opcode",(U8)Opcode::end);
    }

Here is the call graph for this function:

serialize() [6/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		MemoryDef &	memoryDef )

Definition at line 149 of file WASMSerialization.cpp.

    {
        serialize(stream,memoryDef.type);
    }

Here is the call graph for this function:

serialize() [7/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		MemoryType &	memoryType )

Definition at line 88 of file WASMSerialization.cpp.

    {
        Uptr flags = 0;
        if(!Stream::isInput && memoryType.size.max != UINT64_MAX) { flags |= 0x01; }
        #if ENABLE_THREADING_PROTOTYPE
        if(!Stream::isInput && memoryType.isShared) { flags |= 0x10; }
        serializeVarUInt32(stream,flags);
        if(Stream::isInput) { memoryType.isShared = (flags & 0x10) != 0; }
        #else
        serializeVarUInt32(stream,flags);
        #endif
        serialize(stream,memoryType.size,flags & 0x01);
    }

Here is the call graph for this function:

serialize() [8/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		ObjectKind &	kind )

Definition at line 112 of file WASMSerialization.cpp.

    {
        serializeNativeValue(stream,*(U8*)&kind);
    }

Here is the call graph for this function:

serialize() [9/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		SizeConstraints &	sizeConstraints,
		bool	hasMax )

Definition at line 57 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,sizeConstraints.min);
        if(hasMax) { serializeVarUInt32(stream,sizeConstraints.max); }
        else if(Stream::isInput) { sizeConstraints.max = UINT64_MAX; }
    }

Here is the call graph for this function:

serialize() [10/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		TableDef &	tableDef )

Definition at line 143 of file WASMSerialization.cpp.

    {
        serialize(stream,tableDef.type);
    }

Here is the call graph for this function:

serialize() [11/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		TableElementType &	elementType )

Definition at line 65 of file WASMSerialization.cpp.

    {
        serializeNativeValue(stream,elementType);
    }

Here is the call graph for this function:

serialize() [12/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		TableSegment &	tableSegment )

Definition at line 170 of file WASMSerialization.cpp.

    {
        serializeVarUInt32(stream,tableSegment.tableIndex);
        serialize(stream,tableSegment.baseOffset);
        serializeArray(stream,tableSegment.indices,[](Stream& stream,Uptr& functionIndex){serializeVarUInt32(stream,functionIndex);});
    }

Here is the call graph for this function:

serialize() [13/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		TableType &	tableType )

Definition at line 71 of file WASMSerialization.cpp.

    {
        serialize(stream,tableType.elementType);
        
        Uptr flags = 0;
        if(!Stream::isInput && tableType.size.max != UINT64_MAX) { flags |= 0x01; }
        #if ENABLE_THREADING_PROTOTYPE
        if(!Stream::isInput && tableType.isShared) { flags |= 0x10; }
        serializeVarUInt32(stream,flags);
        if(Stream::isInput) { tableType.isShared = (flags & 0x10) != 0; }
        #else
        serializeVarUInt32(stream,flags);
        #endif
        serialize(stream,tableType.size,flags & 0x01);
    }

Here is the call graph for this function:

serialize() [14/14]

template<typename Stream >

void IR::serialize	(	Stream &	stream,
		ValueType &	type )

Definition at line 26 of file WASMSerialization.cpp.

    {
        I8 encodedValueType = -(I8)type;
        serializeVarInt7(stream,encodedValueType);
        if(Stream::isInput) { type = (ValueType)-encodedValueType; }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setDisassemblyNames()

void IR::setDisassemblyNames	(	Module &	module,
		const DisassemblyNames &	names )

Definition at line 131 of file DisassemblyNames.cpp.

    {
        // Replace an existing name section if one is present, or create a new section.
        Uptr userSectionIndex = 0;
        if(!findUserSection(module,"name",userSectionIndex))
        {
            userSectionIndex = module.userSections.size();
            module.userSections.push_back({"name",{}});
        }
 
        ArrayOutputStream stream;
        
        Uptr numFunctionNames = names.functions.size();
        serializeVarUInt32(stream,numFunctionNames);
 
        for(Uptr functionIndex = 0;functionIndex < names.functions.size();++functionIndex)
        {
            std::string functionName = names.functions[functionIndex].name;
            serialize(stream,functionName);
 
            Uptr numLocalNames = names.functions[functionIndex].locals.size();
            serializeVarUInt32(stream,numLocalNames);
            for(Uptr localIndex = 0;localIndex < numLocalNames;++localIndex)
            {
                std::string localName = names.functions[functionIndex].locals[localIndex];
                serialize(stream,localName);
            }
        }
 
        module.userSections[userSectionIndex].data = stream.getBytes();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

validate() [1/8]

void IR::validate

(

GlobalType

type

)

Definition at line 77 of file Validate.cpp.

    {
        validate(type.valueType);
    }

Here is the call graph for this function:

validate() [2/8]

void IR::validate

(

MemoryType

type

)

Definition at line 68 of file Validate.cpp.

    {
        validate(type.size,IR::maxMemoryPages);
        if(ENABLE_THREADING_PROTOTYPE)
        {
            VALIDATE_UNLESS("shared tables must have a maximum size: ",type.isShared && type.size.max == UINT64_MAX);
        }
    }

Here is the call graph for this function:

validate() [3/8]

void IR::validate

(

ObjectKind

kind

)

Definition at line 38 of file Validate.cpp.

    {
        if(kind > ObjectKind::max)
        {
            throw ValidationException("invalid external kind (" + std::to_string((Uptr)kind) + ")");
        }
    }

validate() [4/8]

void IR::validate

(

ResultType

returnType

)

Definition at line 30 of file Validate.cpp.

    {
        if(returnType > ResultType::max)
        {
            throw ValidationException("invalid return type (" + std::to_string((Uptr)returnType) + ")");
        }
    }

validate() [5/8]

void IR::validate	(	SizeConstraints	size,
		Uptr	maxMax )

Definition at line 46 of file Validate.cpp.

    {
        U64 max = size.max == UINT64_MAX ? maxMax : size.max;
        VALIDATE_UNLESS("disjoint size bounds: ",size.min>max);
        VALIDATE_UNLESS("maximum size exceeds limit: ",max>maxMax);
    }

validate() [6/8]

void IR::validate

(

TableElementType

type

)

Definition at line 53 of file Validate.cpp.

    {
        if(type != TableElementType::anyfunc) { throw ValidationException("invalid table element type (" + std::to_string((Uptr)type) + ")"); }
    }

validate() [7/8]

void IR::validate

(

TableType

type

)

Definition at line 58 of file Validate.cpp.

    {
        validate(type.elementType);
        validate(type.size,UINT32_MAX);
        if(ENABLE_THREADING_PROTOTYPE)
        {
            VALIDATE_UNLESS("shared tables must have a maximum size: ",type.isShared && type.size.max == UINT64_MAX);
        }
    }

Here is the call graph for this function:

validate() [8/8]

void IR::validate

(

ValueType

valueType

)

Definition at line 22 of file Validate.cpp.

    {
        if(valueType == ValueType::any || valueType > ValueType::max)
        {
            throw ValidationException("invalid value type (" + std::to_string((Uptr)valueType) + ")");
        }
    }

Here is the caller graph for this function:

validateDefinitions()

void IR::validateDefinitions

(

const IR::Module &

module

)

Definition at line 556 of file Validate.cpp.

        {
            if(type != ResultType::none) { pushOperand(asValueType(type)); }
        }
    };
    
    void validateDefinitions(const Module& module)
    {
        Timing::Timer timer;
        
        for(Uptr typeIndex = 0;typeIndex < module.types.size();++typeIndex)
        {
            const FunctionType* functionType = module.types[typeIndex];
            for(auto parameterType : functionType->parameters) { validate(parameterType); }
            validate(functionType->ret);
        }
 
        for(auto& functionImport : module.functions.imports)
        {
            VALIDATE_INDEX(functionImport.type.index,module.types.size());
        }
        for(auto& tableImport : module.tables.imports) { validate(tableImport.type); }
        for(auto& memoryImport : module.memories.imports) { validate(memoryImport.type); }
        for(auto& globalImport : module.globals.imports)
        {
            validate(globalImport.type);
            VALIDATE_UNLESS("mutable globals cannot be imported: ",globalImport.type.isMutable);
        }
        
        for(Uptr functionDefIndex = 0;functionDefIndex < module.functions.defs.size();++functionDefIndex)
        {
            const FunctionDef& functionDef = module.functions.defs[functionDefIndex];
            VALIDATE_INDEX(functionDef.type.index,module.types.size());
            for(auto localType : functionDef.nonParameterLocalTypes) { validate(localType); }
        }
 
        for(auto& globalDef : module.globals.defs)
        {
            validate(globalDef.type);
            validateInitializer(module,globalDef.initializer,globalDef.type.valueType,"global initializer expression");
        }
        
        for(auto& tableDef : module.tables.defs) { validate(tableDef.type); }
        VALIDATE_UNLESS("too many tables: ",module.tables.size()>1);
 
        for(auto& memoryDef : module.memories.defs) { validate(memoryDef.type); }
        VALIDATE_UNLESS("too many memories: ",module.memories.size()>1);
 
        std::set<std::string> exportNameMap;
        for(auto& exportIt : module.exports)
        {
            switch(exportIt.kind)
            {
            case ObjectKind::function:
                VALIDATE_INDEX(exportIt.index,module.functions.size());
                break;
            case ObjectKind::table:
                VALIDATE_INDEX(exportIt.index,module.tables.size());
                break;
            case ObjectKind::memory:
                VALIDATE_INDEX(exportIt.index,module.memories.size());
                break;
            case ObjectKind::global:
                validateGlobalIndex(module,exportIt.index,false,true,false,"exported global index");
                break;
            default: throw ValidationException("unknown export kind");
            };
 
            VALIDATE_UNLESS("duplicate export: ",exportNameMap.count(exportIt.name));
            exportNameMap.emplace(exportIt.name);
        }
 
        if(module.startFunctionIndex != UINTPTR_MAX)
        {
            VALIDATE_INDEX(module.startFunctionIndex,module.functions.size());
            const FunctionType* startFunctionType = module.types[module.functions.getType(module.startFunctionIndex).index];
            VALIDATE_UNLESS("start function must not have any parameters or results: ",startFunctionType != FunctionType::get());
        }
            
        for(auto& dataSegment : module.dataSegments)
        {
            VALIDATE_INDEX(dataSegment.memoryIndex,module.memories.size());
            validateInitializer(module,dataSegment.baseOffset,ValueType::i32,"data segment base initializer");
        }
 
        for(auto& tableSegment : module.tableSegments)

Here is the caller graph for this function:

validateFunctionIndex()

const FunctionType * IR::validateFunctionIndex	(	const Module &	module,
		Uptr	functionIndex )

Definition at line 119 of file Validate.cpp.

    {
        VALIDATE_INDEX(functionIndex,module.functions.size());
        return module.types[module.functions.getType(functionIndex).index];
    }

Here is the caller graph for this function:

validateGlobalIndex()

ValueType IR::validateGlobalIndex	(	const Module &	module,
		Uptr	globalIndex,
		bool	mustBeMutable,
		bool	mustBeImmutable,
		bool	mustBeImport,
		const char *	context )

Definition at line 109 of file Validate.cpp.

    {
        VALIDATE_INDEX(globalIndex,module.globals.size());
        const GlobalType& globalType = module.globals.getType(globalIndex);
        if(mustBeMutable && !globalType.isMutable) { throw ValidationException("attempting to mutate immutable global"); }
        else if(mustBeImport && globalIndex >= module.globals.imports.size()) { throw ValidationException("global variable initializer expression may only access imported globals"); }
        else if(mustBeImmutable && globalType.isMutable) { throw ValidationException("global variable initializer expression may only access immutable globals"); }
        return globalType.valueType;
    }

Here is the caller graph for this function:

validateImportKind()

void IR::validateImportKind	(	ObjectType	importType,
		ObjectKind	expectedKind )

Definition at line 82 of file Validate.cpp.

    {
        if(importType.kind != expectedKind)
        {
            throw ValidationException("incorrect kind");
        }
    }

validateInitializer()

void IR::validateInitializer	(	const Module &	module,
		const InitializerExpression &	expression,
		ValueType	expectedType,
		const char *	context )

Definition at line 125 of file Validate.cpp.

    {
        switch(expression.type)
        {
        case InitializerExpression::Type::i32_const: validateType(expectedType,ValueType::i32,context); break;
        case InitializerExpression::Type::i64_const: validateType(expectedType,ValueType::i64,context); break;
        case InitializerExpression::Type::f32_const: validateType(expectedType,ValueType::f32,context); break;
        case InitializerExpression::Type::f64_const: validateType(expectedType,ValueType::f64,context); break;
        case InitializerExpression::Type::get_global:
        {
            const ValueType globalValueType = validateGlobalIndex(module,expression.globalIndex,false,true,true,"initializer expression global index");
            validateType(expectedType,globalValueType,context);
            break;
        }
        default:
            throw ValidationException("invalid initializer expression");
        };
    }

Here is the call graph for this function:

validateOperandType()

void IR::validateOperandType	(	ValueType	expectedType,
		ValueType	actualType,
		const char *	context )

Definition at line 100 of file Validate.cpp.

    {
        // Handle polymorphic values popped off the operand stack after unconditional branches.
        if(expectedType != actualType && expectedType != ValueType::any && actualType != ValueType::any)
        {
            throw ValidationException( "type mismatch" );
        }
    }

Here is the caller graph for this function:

validateType()

template<typename Type >

void IR::validateType	(	Type	expectedType,
		Type	actualType,
		const char *	context )

Definition at line 91 of file Validate.cpp.

    {
        if(expectedType != actualType)
        {
            throw ValidationException(
                std::string("type mismatch: expected in ") + context);
        }
    }

Here is the caller graph for this function: