IR::FunctionValidationContext Struct Reference

Public Member Functions
	FunctionValidationContext (const Module &inModule, const FunctionDef &inFunctionDef)
Uptr	getControlStackSize ()
void	logOperator (const std::string &operatorDescription)
void	unknown (Opcode opcode)
void	block (ControlStructureImm imm)
void	loop (ControlStructureImm imm)
void	if_ (ControlStructureImm imm)
void	else_ (NoImm imm)
void	end (NoImm)
void	return_ (NoImm)
void	br (BranchImm imm)
void	br_table (BranchTableImm imm)
void	br_if (BranchImm imm)
void	unreachable (NoImm)
void	drop (NoImm)
void	select (NoImm)
void	get_local (GetOrSetVariableImm< false > imm)
void	set_local (GetOrSetVariableImm< false > imm)
void	tee_local (GetOrSetVariableImm< false > imm)
void	get_global (GetOrSetVariableImm< true > imm)
void	set_global (GetOrSetVariableImm< true > imm)
void	call (CallImm imm)
void	call_indirect (CallIndirectImm imm)
void	validateImm (NoImm)
template<typename nativeType >
void	validateImm (LiteralImm< nativeType > imm)
template<Uptr naturalAlignmentLog2>
void	validateImm (LoadOrStoreImm< naturalAlignmentLog2 > imm)
void	validateImm (MemoryImm)

Detailed Description

Definition at line 144 of file Validate.cpp.

Constructor & Destructor Documentation

FunctionValidationContext()

IR::FunctionValidationContext::FunctionValidationContext ( const Module & inModule, const FunctionDef & inFunctionDef )

inline

Definition at line 146 of file Validate.cpp.

        : module(inModule), functionDef(inFunctionDef), functionType(inModule.types[inFunctionDef.type.index])
        {
            // Initialize the local types.
            locals.reserve(functionType->parameters.size() + functionDef.nonParameterLocalTypes.size());
            locals = functionType->parameters;
            locals.insert(locals.end(),functionDef.nonParameterLocalTypes.begin(),functionDef.nonParameterLocalTypes.end());
 
            // Push the function context onto the control stack.
            pushControlStack(ControlContext::Type::function,functionType->ret,functionType->ret);
        }

Member Function Documentation

block()

void IR::FunctionValidationContext::block ( ControlStructureImm imm )

inline

Definition at line 199 of file Validate.cpp.

        {
            validate(imm.resultType);
            pushControlStack(ControlContext::Type::block,imm.resultType,imm.resultType);
        }

Here is the call graph for this function:

br()

void IR::FunctionValidationContext::br ( BranchImm imm )

inline

Definition at line 234 of file Validate.cpp.

        {
            popAndValidateResultType("br argument",getBranchTargetByDepth(imm.targetDepth).branchArgumentType);
            enterUnreachable();
        }

br_if()

void IR::FunctionValidationContext::br_if ( BranchImm imm )

inline

Definition at line 255 of file Validate.cpp.

        {
            popAndValidateOperand("br_if condition",ValueType::i32);
            popAndValidateResultType("br_if argument",getBranchTargetByDepth(imm.targetDepth).branchArgumentType);
            pushOperand(getBranchTargetByDepth(imm.targetDepth).branchArgumentType);
        }

br_table()

void IR::FunctionValidationContext::br_table ( BranchTableImm imm )

inline

Definition at line 239 of file Validate.cpp.

        {
            popAndValidateOperand("br_table index",ValueType::i32);
            const ResultType defaultTargetArgumentType = getBranchTargetByDepth(imm.defaultTargetDepth).branchArgumentType;
            popAndValidateResultType("br_table argument",defaultTargetArgumentType);
 
            WAVM_ASSERT_THROW(imm.branchTableIndex < functionDef.branchTables.size());
            const std::vector<U32>& targetDepths = functionDef.branchTables[imm.branchTableIndex];
            for(Uptr targetIndex = 0;targetIndex < targetDepths.size();++targetIndex)
            {
                const ResultType targetArgumentType = getBranchTargetByDepth(targetDepths[targetIndex]).branchArgumentType;
                VALIDATE_UNLESS("br_table target argument must match default target argument: ",targetArgumentType != defaultTargetArgumentType);
            }
 
            enterUnreachable();
        }

call()

void IR::FunctionValidationContext::call ( CallImm imm )

inline

Definition at line 305 of file Validate.cpp.

        {
            const FunctionType* calleeType = validateFunctionIndex(module,imm.functionIndex);
            popAndValidateOperands("call arguments",calleeType->parameters.data(),(Uptr)calleeType->parameters.size());
            pushOperand(calleeType->ret);
        }

Here is the call graph for this function:

call_indirect()

void IR::FunctionValidationContext::call_indirect ( CallIndirectImm imm )

inline

Definition at line 311 of file Validate.cpp.

        {
            VALIDATE_INDEX(imm.type.index,module.types.size());
            VALIDATE_UNLESS("call_indirect is only valid if there is a default function table: ",module.tables.size()==0);
            const FunctionType* calleeType = module.types[imm.type.index];
            popAndValidateOperand("call_indirect function index",ValueType::i32);
            popAndValidateOperands("call_indirect arguments",calleeType->parameters.data(),(Uptr)calleeType->parameters.size());
            pushOperand(calleeType->ret);
        }

drop()

void IR::FunctionValidationContext::drop ( NoImm )

inline

Definition at line 266 of file Validate.cpp.

        {
            popOperand();
        }

else_()

void IR::FunctionValidationContext::else_ ( NoImm imm )

inline

Definition at line 215 of file Validate.cpp.

        {
            if( controlStack.size() == 0 ) throw ValidationException( "control stack empty" );
            popAndValidateResultType("if result",controlStack.back().resultType);
            popControlStack(true);
        }

end()

void IR::FunctionValidationContext::end ( NoImm )

inline

Definition at line 221 of file Validate.cpp.

        {
            if( controlStack.size() == 0 ) throw ValidationException( "control stack empty" );
            popAndValidateResultType("end result",controlStack.back().resultType);
            popControlStack();
        }

get_global()

void IR::FunctionValidationContext::get_global ( GetOrSetVariableImm< true > imm )

inline

Definition at line 296 of file Validate.cpp.

        {
            pushOperand(validateGlobalIndex(module,imm.variableIndex,false,false,false,"get_global"));
        }

Here is the call graph for this function:

get_local()

void IR::FunctionValidationContext::get_local ( GetOrSetVariableImm< false > imm )

inline

Definition at line 281 of file Validate.cpp.

        {
            pushOperand(validateLocalIndex(imm.variableIndex));
        }

getControlStackSize()

Uptr IR::FunctionValidationContext::getControlStackSize ( )

inline

Definition at line 158 of file Validate.cpp.

{ return controlStack.size(); }

if_()

void IR::FunctionValidationContext::if_ ( ControlStructureImm imm )

inline

Definition at line 209 of file Validate.cpp.

        {
            validate(imm.resultType);
            popAndValidateOperand("if condition",ValueType::i32);
            pushControlStack(ControlContext::Type::ifThen,imm.resultType,imm.resultType);
        }

Here is the call graph for this function:

logOperator()

void IR::FunctionValidationContext::logOperator ( const std::string & operatorDescription )

inline

Definition at line 160 of file Validate.cpp.

        {
            if(ENABLE_LOGGING)
            {
                std::string controlStackString;
                for(Uptr stackIndex = 0;stackIndex < controlStack.size();++stackIndex)
                {
                    if(!controlStack[stackIndex].isReachable) { controlStackString += "("; }
                    switch(controlStack[stackIndex].type)
                    {
                    case ControlContext::Type::function: controlStackString += "F"; break;
                    case ControlContext::Type::block: controlStackString += "B"; break;
                    case ControlContext::Type::ifThen: controlStackString += "T"; break;
                    case ControlContext::Type::ifElse: controlStackString += "E"; break;
                    case ControlContext::Type::loop: controlStackString += "L"; break;
                    default: Errors::unreachable();
                    };
                    if(!controlStack[stackIndex].isReachable) { controlStackString += ")"; }
                }
 
                std::string stackString;
                const Uptr stackBase = controlStack.size() == 0 ? 0 : controlStack.back().outerStackSize;
                for(Uptr stackIndex = 0;stackIndex < stack.size();++stackIndex)
                {
                    if(stackIndex == stackBase) { stackString += "| "; }
                    stackString +=  asString(stack[stackIndex]);
                    stackString +=  " ";
                }
                if(stack.size() == stackBase) { stackString += "|"; }
 
                Log::printf(Log::Category::debug,"%-50s %-50s %-50s\n",controlStackString.c_str(),operatorDescription.c_str(),stackString.c_str());
            }
        }

Here is the call graph for this function:

loop()

void IR::FunctionValidationContext::loop ( ControlStructureImm imm )

inline

Definition at line 204 of file Validate.cpp.

        {
            validate(imm.resultType);
            pushControlStack(ControlContext::Type::loop,ResultType::none,imm.resultType);
        }

Here is the call graph for this function:

return_()

void IR::FunctionValidationContext::return_ ( NoImm )

inline

Definition at line 228 of file Validate.cpp.

        {
            popAndValidateResultType("ret",functionType->ret);
            enterUnreachable();
        }

select()

void IR::FunctionValidationContext::select ( NoImm )

inline

Definition at line 271 of file Validate.cpp.

        {
            const ValueType condition = popOperand();
            const ValueType falseType = popOperand();
            const ValueType trueType = popOperand();
            validateOperandType(ValueType::i32,condition,"select condition");
            validateOperandType(falseType,trueType,"select operands");
            pushOperand(falseType);
        }

Here is the call graph for this function:

set_global()

void IR::FunctionValidationContext::set_global ( GetOrSetVariableImm< true > imm )

inline

Definition at line 300 of file Validate.cpp.

        {
            popAndValidateOperand("set_global",validateGlobalIndex(module,imm.variableIndex,true,false,false,"set_global"));
        }

Here is the call graph for this function:

set_local()

void IR::FunctionValidationContext::set_local ( GetOrSetVariableImm< false > imm )

inline

Definition at line 285 of file Validate.cpp.

        {
            popAndValidateOperand("set_local",validateLocalIndex(imm.variableIndex));
        }

tee_local()

void IR::FunctionValidationContext::tee_local ( GetOrSetVariableImm< false > imm )

inline

Definition at line 289 of file Validate.cpp.

        {
            const ValueType localType = validateLocalIndex(imm.variableIndex);
            popAndValidateOperand("tee_local",localType);
            pushOperand(localType);
        }

unknown()

void IR::FunctionValidationContext::unknown ( Opcode opcode )

inline

Definition at line 195 of file Validate.cpp.

        {
            throw ValidationException("Unknown opcode: " + std::to_string((Uptr)opcode));
        }

unreachable()

void IR::FunctionValidationContext::unreachable ( NoImm )

inline

Definition at line 262 of file Validate.cpp.

        {
            enterUnreachable();
        }

validateImm() [1/4]

template<typename nativeType >

void IR::FunctionValidationContext::validateImm ( LiteralImm< nativeType > imm )

inline

Definition at line 324 of file Validate.cpp.

{}

validateImm() [2/4]

template<Uptr naturalAlignmentLog2>

void IR::FunctionValidationContext::validateImm ( LoadOrStoreImm< naturalAlignmentLog2 > imm )

inline

Definition at line 327 of file Validate.cpp.

        {
            VALIDATE_UNLESS("load or store alignment greater than natural alignment: ",imm.alignmentLog2>naturalAlignmentLog2);
            VALIDATE_UNLESS("load or store in module without default memory: ",module.memories.size()==0);
        }

validateImm() [3/4]

void IR::FunctionValidationContext::validateImm ( MemoryImm )

inline

Definition at line 333 of file Validate.cpp.

        {
            VALIDATE_UNLESS("current_memory and grow_memory are only valid if there is a default memory",module.memories.size() == 0);
        }

validateImm() [4/4]

void IR::FunctionValidationContext::validateImm ( NoImm )

inline

Definition at line 321 of file Validate.cpp.

{}

---

The documentation for this struct was generated from the following file:

• libraries/wasm-jit/Source/IR/Validate.cpp