| Absolute File Name: | /home/opencoverage/opencoverage/guest-scripts/qtdeclarative/src/qtdeclarative/src/qml/compiler/qv4instr_moth_p.h |
| Switch to Source code | Preprocessed file |
| Line | Source | Count | ||||||
|---|---|---|---|---|---|---|---|---|
| 1 | - | |||||||
| 2 | - | |||||||
| 3 | namespace QV4 { | - | ||||||
| 4 | - | |||||||
| 5 | namespace CompiledData { | - | ||||||
| 6 | struct CodeOffsetToLine; | - | ||||||
| 7 | } | - | ||||||
| 8 | - | |||||||
| 9 | namespace Moth { | - | ||||||
| 10 | - | |||||||
| 11 | class StackSlot { | - | ||||||
| 12 | int index; | - | ||||||
| 13 | - | |||||||
| 14 | public: | - | ||||||
| 15 | static StackSlot createRegister(int index) { | - | ||||||
| 16 | ((index >= 0) ? static_cast<void>(0) : qt_assert("index >= 0", __FILE__, 501)); | - | ||||||
| 17 | StackSlot t; | - | ||||||
| 18 | t.index = index; | - | ||||||
| 19 | return executed 22754905 times by 139 tests: t;return t;Executed by:
executed 22754905 times by 139 tests: return t;Executed by:
| 22754905 | ||||||
| 20 | } | - | ||||||
| 21 | - | |||||||
| 22 | int stackSlot() const { return executed 70467 times by 10 tests: index;return index;Executed by:
executed 70467 times by 10 tests: }return index;Executed by:
| 70467 | ||||||
| 23 | operator int() const { return executed 28564598 times by 139 tests: index;return index;Executed by:
executed 28564598 times by 139 tests: }return index;Executed by:
| 28564598 | ||||||
| 24 | }; | - | ||||||
| 25 | - | |||||||
| 26 | inline bool operator==(const StackSlot &l, const StackSlot &r) { return executed 33468 times by 10 tests: l.stackSlot() == r.stackSlot();return l.stackSlot() == r.stackSlot();Executed by:
executed 33468 times by 10 tests: }return l.stackSlot() == r.stackSlot();Executed by:
| 33468 | ||||||
| 27 | inline bool operator!=(const StackSlot &l, const StackSlot &r) { return never executed: l.stackSlot() != r.stackSlot();return l.stackSlot() != r.stackSlot();never executed: }return l.stackSlot() != r.stackSlot(); | 0 | ||||||
| 28 | - | |||||||
| 29 | - | |||||||
| 30 | - | |||||||
| 31 | void dumpConstantTable(const Value *constants, uint count); | - | ||||||
| 32 | void dumpBytecode(const char *bytecode, int len, int nLocals, int nFormals, int startLine = 1, | - | ||||||
| 33 | const QVector<CompiledData::CodeOffsetToLine> &lineNumberMapping = QVector<CompiledData::CodeOffsetToLine>()); | - | ||||||
| 34 | inline void dumpBytecode(const QByteArray &bytecode, int nLocals, int nFormals, int startLine = 1, | - | ||||||
| 35 | const QVector<CompiledData::CodeOffsetToLine> &lineNumberMapping = QVector<CompiledData::CodeOffsetToLine>()) { | - | ||||||
| 36 | dumpBytecode(bytecode.constData(), bytecode.length(), nLocals, nFormals, startLine, lineNumberMapping); | - | ||||||
| 37 | } never executed: end of block | 0 | ||||||
| 38 | - | |||||||
| 39 | union Instr | - | ||||||
| 40 | { | - | ||||||
| 41 | enum class Type { | - | ||||||
| 42 | Nop, Nop_Wide, Ret, Ret_Wide, LoadConst, LoadConst_Wide, LoadZero, LoadZero_Wide, LoadTrue, LoadTrue_Wide, LoadFalse, LoadFalse_Wide, LoadNull, LoadNull_Wide, LoadUndefined, LoadUndefined_Wide, LoadInt, LoadInt_Wide, LoadRuntimeString, LoadRuntimeString_Wide, MoveConst, MoveConst_Wide, LoadReg, LoadReg_Wide, StoreReg, StoreReg_Wide, MoveReg, MoveReg_Wide, LoadLocal, LoadLocal_Wide, StoreLocal, StoreLocal_Wide, LoadScopedLocal, LoadScopedLocal_Wide, StoreScopedLocal, StoreScopedLocal_Wide, MoveRegExp, MoveRegExp_Wide, LoadClosure, LoadClosure_Wide, LoadName, LoadName_Wide, LoadGlobalLookup, LoadGlobalLookup_Wide, StoreNameSloppy, StoreNameSloppy_Wide, StoreNameStrict, StoreNameStrict_Wide, LoadElement, LoadElement_Wide, StoreElement, StoreElement_Wide, LoadProperty, LoadProperty_Wide, GetLookup, GetLookup_Wide, StoreProperty, StoreProperty_Wide, SetLookup, SetLookup_Wide, LoadSuperProperty, LoadSuperProperty_Wide, StoreSuperProperty, StoreSuperProperty_Wide, StoreScopeObjectProperty, StoreScopeObjectProperty_Wide, StoreContextObjectProperty, StoreContextObjectProperty_Wide, LoadScopeObjectProperty, LoadScopeObjectProperty_Wide, LoadContextObjectProperty, LoadContextObjectProperty_Wide, LoadIdObject, LoadIdObject_Wide, ConvertThisToObject, ConvertThisToObject_Wide, ToObject, ToObject_Wide, Jump, Jump_Wide, JumpTrue, JumpTrue_Wide, JumpFalse, JumpFalse_Wide, JumpNoException, JumpNoException_Wide, JumpNotUndefined, JumpNotUndefined_Wide, CmpEqNull, CmpEqNull_Wide, CmpNeNull, CmpNeNull_Wide, CmpEqInt, CmpEqInt_Wide, CmpNeInt, CmpNeInt_Wide, CmpEq, CmpEq_Wide, CmpNe, CmpNe_Wide, CmpGt, CmpGt_Wide, CmpGe, CmpGe_Wide, CmpLt, CmpLt_Wide, CmpLe, CmpLe_Wide, CmpStrictEqual, CmpStrictEqual_Wide, CmpStrictNotEqual, CmpStrictNotEqual_Wide, CmpIn, CmpIn_Wide, CmpInstanceOf, CmpInstanceOf_Wide, UNot, UNot_Wide, UPlus, UPlus_Wide, UMinus, UMinus_Wide, UCompl, UCompl_Wide, Increment, Increment_Wide, Decrement, Decrement_Wide, Add, Add_Wide, BitAnd, BitAnd_Wide, BitOr, BitOr_Wide, BitXor, BitXor_Wide, UShr, UShr_Wide, Shr, Shr_Wide, Shl, Shl_Wide, BitAndConst, BitAndConst_Wide, BitOrConst, BitOrConst_Wide, BitXorConst, BitXorConst_Wide, UShrConst, UShrConst_Wide, ShrConst, ShrConst_Wide, ShlConst, ShlConst_Wide, Exp, Exp_Wide, Mul, Mul_Wide, Div, Div_Wide, Mod, Mod_Wide, Sub, Sub_Wide, CallValue, CallValue_Wide, CallProperty, CallProperty_Wide, CallPropertyLookup, CallPropertyLookup_Wide, CallElement, CallElement_Wide, CallName, CallName_Wide, CallPossiblyDirectEval, CallPossiblyDirectEval_Wide, CallGlobalLookup, CallGlobalLookup_Wide, CallScopeObjectProperty, CallScopeObjectProperty_Wide, CallContextObjectProperty, CallContextObjectProperty_Wide, CallWithSpread, CallWithSpread_Wide, Construct, Construct_Wide, ConstructWithSpread, ConstructWithSpread_Wide, SetUnwindHandler, SetUnwindHandler_Wide, UnwindDispatch, UnwindDispatch_Wide, UnwindToLabel, UnwindToLabel_Wide, ThrowException, ThrowException_Wide, GetException, GetException_Wide, SetException, SetException_Wide, CreateCallContext, CreateCallContext_Wide, PushCatchContext, PushCatchContext_Wide, PushWithContext, PushWithContext_Wide, PushBlockContext, PushBlockContext_Wide, CloneBlockContext, CloneBlockContext_Wide, PopContext, PopContext_Wide, GetIterator, GetIterator_Wide, IteratorNext, IteratorNext_Wide, IteratorClose, IteratorClose_Wide, DestructureRestElement, DestructureRestElement_Wide, DeleteProperty, DeleteProperty_Wide, DeleteName, DeleteName_Wide, TypeofName, TypeofName_Wide, TypeofValue, TypeofValue_Wide, DeclareVar, DeclareVar_Wide, DefineArray, DefineArray_Wide, DefineObjectLiteral, DefineObjectLiteral_Wide, CreateMappedArgumentsObject, CreateMappedArgumentsObject_Wide, CreateUnmappedArgumentsObject, CreateUnmappedArgumentsObject_Wide, CreateRestParameter, CreateRestParameter_Wide, LoadQmlContext, LoadQmlContext_Wide, LoadQmlImportedScripts, LoadQmlImportedScripts_Wide, Yield, Yield_Wide, Resume, Resume_Wide, CreateClass, CreateClass_Wide, LoadSuperConstructor, LoadSuperConstructor_Wide, PushScriptContext, PushScriptContext_Wide, PopScriptContext, PopScriptContext_Wide, Debug, Debug_Wide, | - | ||||||
| 43 | }; | - | ||||||
| 44 | - | |||||||
| 45 | static Type wideInstructionType(Type t) { return executed 44860078 times by 140 tests: Type(int(t) | 1);return Type(int(t) | 1);Executed by:
executed 44860078 times by 140 tests: }return Type(int(t) | 1);Executed by:
| 44860078 | ||||||
| 46 | static Type narrowInstructionType(Type t) { return executed 44968848 times by 140 tests: Type(int(t) & ~1);return Type(int(t) & ~1);Executed by:
executed 44968848 times by 140 tests: }return Type(int(t) & ~1);Executed by:
| 44968848 | ||||||
| 47 | static bool isWide(Type t) { return executed 5549329 times by 73 tests: int(t) & 1;return int(t) & 1;Executed by:
executed 5549329 times by 73 tests: }return int(t) & 1;Executed by:
| 5549329 | ||||||
| 48 | static bool isNarrow(Type t) { return never executed: !(int(t) & 1);return !(int(t) & 1);never executed: }return !(int(t) & 1); | 0 | ||||||
| 49 | static int encodedLength(Type t) { return executed 92515746 times by 140 tests: int(t) >= 256 ? 2 : 1;return int(t) >= 256 ? 2 : 1;Executed by:
executed 92515746 times by 140 tests: }return int(t) >= 256 ? 2 : 1;Executed by:
| 92515746 | ||||||
| 50 | - | |||||||
| 51 | static Type unpack(const uchar *c) { if (c[0] == 0x1
executed 714 times by 2 tests: Type(0x100 + c[1]);return Type(0x100 + c[1]);Executed by:
executed 714 times by 2 tests: returnreturn Type(0x100 + c[1]);Executed by:
executed 44956164 times by 140 tests: Type(c[0]);return Type(c[0]);Executed by:
executed 44956164 times by 140 tests: }return Type(c[0]);Executed by:
| 714-44956164 | ||||||
| 52 | static uchar *pack(uchar *c, Type t) { | - | ||||||
| 53 | if (uint(t) >= 256
| 1428-88822124 | ||||||
| 54 | c[0] = 0x1; | - | ||||||
| 55 | c[1] = uint(t) &0xff; | - | ||||||
| 56 | return executed 1428 times by 2 tests: c + 2;return c + 2;Executed by:
executed 1428 times by 2 tests: return c + 2;Executed by:
| 1428 | ||||||
| 57 | } | - | ||||||
| 58 | c[0] = uchar(uint(t)); | - | ||||||
| 59 | return executed 88878987 times by 140 tests: c + 1;return c + 1;Executed by:
executed 88878987 times by 140 tests: return c + 1;Executed by:
| 88878987 | ||||||
| 60 | } | - | ||||||
| 61 | - | |||||||
| 62 | struct instr_Nop { }; struct instr_Ret { }; struct instr_LoadConst { int index; }; struct instr_LoadZero { }; struct instr_LoadTrue { }; struct instr_LoadFalse { }; struct instr_LoadNull { }; struct instr_LoadUndefined { }; struct instr_LoadInt { int value; }; struct instr_LoadRuntimeString { int stringId; }; struct instr_MoveConst { int constIndex; int destTemp; }; struct instr_LoadReg { int reg; }; struct instr_StoreReg { int reg; }; struct instr_MoveReg { int srcReg; int destReg; }; struct instr_LoadLocal { int index; }; struct instr_StoreLocal { int index; }; struct instr_LoadScopedLocal { int scope; int index; }; struct instr_StoreScopedLocal { int scope; int index; }; struct instr_MoveRegExp { int regExpId; int destReg; }; struct instr_LoadClosure { int value; }; struct instr_LoadName { int name; }; struct instr_LoadGlobalLookup { int index; }; struct instr_StoreNameSloppy { int name; }; struct instr_StoreNameStrict { int name; }; struct instr_LoadElement { int base; }; struct instr_StoreElement { int base; int index; }; struct instr_LoadProperty { int name; }; struct instr_GetLookup { int index; }; struct instr_StoreProperty { int name; int base; }; struct instr_SetLookup { int index; int base; }; struct instr_LoadSuperProperty { int property; }; struct instr_StoreSuperProperty { int property; }; struct instr_StoreScopeObjectProperty { int base; int propertyIndex; }; struct instr_StoreContextObjectProperty { int base; int propertyIndex; }; struct instr_LoadScopeObjectProperty { int propertyIndex; int base; int captureRequired; }; struct instr_LoadContextObjectProperty { int propertyIndex; int base; int captureRequired; }; struct instr_LoadIdObject { int index; int base; }; struct instr_ConvertThisToObject { }; struct instr_ToObject { }; struct instr_Jump { int offset; }; struct instr_JumpTrue { int offset; }; struct instr_JumpFalse { int offset; }; struct instr_JumpNoException { int offset; }; struct instr_JumpNotUndefined { int offset; }; struct instr_CmpEqNull { }; struct instr_CmpNeNull { }; struct instr_CmpEqInt { int lhs; }; struct instr_CmpNeInt { int lhs; }; struct instr_CmpEq { int lhs; }; struct instr_CmpNe { int lhs; }; struct instr_CmpGt { int lhs; }; struct instr_CmpGe { int lhs; }; struct instr_CmpLt { int lhs; }; struct instr_CmpLe { int lhs; }; struct instr_CmpStrictEqual { int lhs; }; struct instr_CmpStrictNotEqual { int lhs; }; struct instr_CmpIn { int lhs; }; struct instr_CmpInstanceOf { int lhs; }; struct instr_UNot { }; struct instr_UPlus { }; struct instr_UMinus { }; struct instr_UCompl { }; struct instr_Increment { }; struct instr_Decrement { }; struct instr_Add { int lhs; }; struct instr_BitAnd { int lhs; }; struct instr_BitOr { int lhs; }; struct instr_BitXor { int lhs; }; struct instr_UShr { int lhs; }; struct instr_Shr { int lhs; }; struct instr_Shl { int lhs; }; struct instr_BitAndConst { int rhs; }; struct instr_BitOrConst { int rhs; }; struct instr_BitXorConst { int rhs; }; struct instr_UShrConst { int rhs; }; struct instr_ShrConst { int rhs; }; struct instr_ShlConst { int rhs; }; struct instr_Exp { int lhs; }; struct instr_Mul { int lhs; }; struct instr_Div { int lhs; }; struct instr_Mod { int lhs; }; struct instr_Sub { int lhs; }; struct instr_CallValue { int name; int argc; int argv; }; struct instr_CallProperty { int name; int base; int argc; int argv; }; struct instr_CallPropertyLookup { int lookupIndex; int base; int argc; int argv; }; struct instr_CallElement { int base; int index; int argc; int argv; }; struct instr_CallName { int name; int argc; int argv; }; struct instr_CallPossiblyDirectEval { int argc; int argv; }; struct instr_CallGlobalLookup { int index; int argc; int argv; }; struct instr_CallScopeObjectProperty { int name; int base; int argc; int argv; }; struct instr_CallContextObjectProperty { int name; int base; int argc; int argv; }; struct instr_CallWithSpread { int func; int thisObject; int argc; int argv; }; struct instr_Construct { int func; int argc; int argv; }; struct instr_ConstructWithSpread { int func; int argc; int argv; }; struct instr_SetUnwindHandler { int offset; }; struct instr_UnwindDispatch { }; struct instr_UnwindToLabel { int level; int offset; }; struct instr_ThrowException { }; struct instr_GetException { }; struct instr_SetException { }; struct instr_CreateCallContext { }; struct instr_PushCatchContext { int index; int name; }; struct instr_PushWithContext { }; struct instr_PushBlockContext { int index; }; struct instr_CloneBlockContext { }; struct instr_PopContext { }; struct instr_GetIterator { int iterator; }; struct instr_IteratorNext { int value; }; struct instr_IteratorClose { int done; }; struct instr_DestructureRestElement { }; struct instr_DeleteProperty { int base; int index; }; struct instr_DeleteName { int name; }; struct instr_TypeofName { int name; }; struct instr_TypeofValue { }; struct instr_DeclareVar { int varName; int isDeletable; }; struct instr_DefineArray { int argc; int args; }; struct instr_DefineObjectLiteral { int internalClassId; int argc; int args; }; struct instr_CreateMappedArgumentsObject { }; struct instr_CreateUnmappedArgumentsObject { }; struct instr_CreateRestParameter { int argIndex; }; struct instr_LoadQmlContext { int result; }; struct instr_LoadQmlImportedScripts { int result; }; struct instr_Yield { }; struct instr_Resume { int offset; }; struct instr_CreateClass { int classIndex; int heritage; int computedNames; }; struct instr_LoadSuperConstructor { }; struct instr_PushScriptContext { int index; }; struct instr_PopScriptContext { }; struct instr_Debug { }; | - | ||||||
| 63 | - | |||||||
| 64 | instr_Nop Nop; instr_Ret Ret; instr_LoadConst LoadConst; instr_LoadZero LoadZero; instr_LoadTrue LoadTrue; instr_LoadFalse LoadFalse; instr_LoadNull LoadNull; instr_LoadUndefined LoadUndefined; instr_LoadInt LoadInt; instr_LoadRuntimeString LoadRuntimeString; instr_MoveConst MoveConst; instr_LoadReg LoadReg; instr_StoreReg StoreReg; instr_MoveReg MoveReg; instr_LoadLocal LoadLocal; instr_StoreLocal StoreLocal; instr_LoadScopedLocal LoadScopedLocal; instr_StoreScopedLocal StoreScopedLocal; instr_MoveRegExp MoveRegExp; instr_LoadClosure LoadClosure; instr_LoadName LoadName; instr_LoadGlobalLookup LoadGlobalLookup; instr_StoreNameSloppy StoreNameSloppy; instr_StoreNameStrict StoreNameStrict; instr_LoadElement LoadElement; instr_StoreElement StoreElement; instr_LoadProperty LoadProperty; instr_GetLookup GetLookup; instr_StoreProperty StoreProperty; instr_SetLookup SetLookup; instr_LoadSuperProperty LoadSuperProperty; instr_StoreSuperProperty StoreSuperProperty; instr_StoreScopeObjectProperty StoreScopeObjectProperty; instr_StoreContextObjectProperty StoreContextObjectProperty; instr_LoadScopeObjectProperty LoadScopeObjectProperty; instr_LoadContextObjectProperty LoadContextObjectProperty; instr_LoadIdObject LoadIdObject; instr_ConvertThisToObject ConvertThisToObject; instr_ToObject ToObject; instr_Jump Jump; instr_JumpTrue JumpTrue; instr_JumpFalse JumpFalse; instr_JumpNoException JumpNoException; instr_JumpNotUndefined JumpNotUndefined; instr_CmpEqNull CmpEqNull; instr_CmpNeNull CmpNeNull; instr_CmpEqInt CmpEqInt; instr_CmpNeInt CmpNeInt; instr_CmpEq CmpEq; instr_CmpNe CmpNe; instr_CmpGt CmpGt; instr_CmpGe CmpGe; instr_CmpLt CmpLt; instr_CmpLe CmpLe; instr_CmpStrictEqual CmpStrictEqual; instr_CmpStrictNotEqual CmpStrictNotEqual; instr_CmpIn CmpIn; instr_CmpInstanceOf CmpInstanceOf; instr_UNot UNot; instr_UPlus UPlus; instr_UMinus UMinus; instr_UCompl UCompl; instr_Increment Increment; instr_Decrement Decrement; instr_Add Add; instr_BitAnd BitAnd; instr_BitOr BitOr; instr_BitXor BitXor; instr_UShr UShr; instr_Shr Shr; instr_Shl Shl; instr_BitAndConst BitAndConst; instr_BitOrConst BitOrConst; instr_BitXorConst BitXorConst; instr_UShrConst UShrConst; instr_ShrConst ShrConst; instr_ShlConst ShlConst; instr_Exp Exp; instr_Mul Mul; instr_Div Div; instr_Mod Mod; instr_Sub Sub; instr_CallValue CallValue; instr_CallProperty CallProperty; instr_CallPropertyLookup CallPropertyLookup; instr_CallElement CallElement; instr_CallName CallName; instr_CallPossiblyDirectEval CallPossiblyDirectEval; instr_CallGlobalLookup CallGlobalLookup; instr_CallScopeObjectProperty CallScopeObjectProperty; instr_CallContextObjectProperty CallContextObjectProperty; instr_CallWithSpread CallWithSpread; instr_Construct Construct; instr_ConstructWithSpread ConstructWithSpread; instr_SetUnwindHandler SetUnwindHandler; instr_UnwindDispatch UnwindDispatch; instr_UnwindToLabel UnwindToLabel; instr_ThrowException ThrowException; instr_GetException GetException; instr_SetException SetException; instr_CreateCallContext CreateCallContext; instr_PushCatchContext PushCatchContext; instr_PushWithContext PushWithContext; instr_PushBlockContext PushBlockContext; instr_CloneBlockContext CloneBlockContext; instr_PopContext PopContext; instr_GetIterator GetIterator; instr_IteratorNext IteratorNext; instr_IteratorClose IteratorClose; instr_DestructureRestElement DestructureRestElement; instr_DeleteProperty DeleteProperty; instr_DeleteName DeleteName; instr_TypeofName TypeofName; instr_TypeofValue TypeofValue; instr_DeclareVar DeclareVar; instr_DefineArray DefineArray; instr_DefineObjectLiteral DefineObjectLiteral; instr_CreateMappedArgumentsObject CreateMappedArgumentsObject; instr_CreateUnmappedArgumentsObject CreateUnmappedArgumentsObject; instr_CreateRestParameter CreateRestParameter; instr_LoadQmlContext LoadQmlContext; instr_LoadQmlImportedScripts LoadQmlImportedScripts; instr_Yield Yield; instr_Resume Resume; instr_CreateClass CreateClass; instr_LoadSuperConstructor LoadSuperConstructor; instr_PushScriptContext PushScriptContext; instr_PopScriptContext PopScriptContext; instr_Debug Debug; | - | ||||||
| 65 | - | |||||||
| 66 | int argumentsAsInts[4]; | - | ||||||
| 67 | }; | - | ||||||
| 68 | - | |||||||
| 69 | struct InstrInfo | - | ||||||
| 70 | { | - | ||||||
| 71 | static const int argumentCount[]; | - | ||||||
| 72 | static int size(Instr::Type type); | - | ||||||
| 73 | }; | - | ||||||
| 74 | - | |||||||
| 75 | template<int N> | - | ||||||
| 76 | struct InstrMeta { | - | ||||||
| 77 | }; | - | ||||||
| 78 | - | |||||||
| 79 | - | |||||||
| 80 | #pragma GCC diagnostic push | - | ||||||
| 81 | - | |||||||
| 82 | - | |||||||
| 83 | #pragma GCC diagnostic ignored "-Wuninitialized" | - | ||||||
| 84 | - | |||||||
| 85 | - | |||||||
| 86 | #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" | - | ||||||
| 87 | - | |||||||
| 88 | template<> struct InstrMeta<int(Instr::Type::Nop)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Nop)) }; typedef Instr::instr_Nop DataType; static const DataType &data(const Instr &instr) { return never executed: instr.Nop;return instr.Nop;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Nop), reinterpret_cast<const char *>(&v), Size); }return instr.Nop;never executed: }; template<> struct InstrMeta<int(Instr::Type::Ret)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Ret)) }; typedef Instr::instr_Ret DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.Ret;return instr.Ret;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Ret), reinterpret_cast<const char *>(&v), Size); }return instr.Ret;executed 3824220 times by 140 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadConst)) }; typedef Instr::instr_LoadConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadConst;return instr.LoadConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadConst), reinterpret_cast<const char *>(&v), Size); }return instr.LoadConst;executed 18598 times by 24 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadZero)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadZero)) }; typedef Instr::instr_LoadZero DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadZero;return instr.LoadZero;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadZero), reinterpret_cast<const char *>(&v), Size); }return instr.LoadZero;executed 163459 times by 48 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadTrue)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadTrue)) }; typedef Instr::instr_LoadTrue DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadTrue;return instr.LoadTrue;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadTrue), reinterpret_cast<const char *>(&v), Size); }return instr.LoadTrue;executed 144350 times by 59 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadFalse)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadFalse)) }; typedef Instr::instr_LoadFalse DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadFalse;return instr.LoadFalse;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadFalse), reinterpret_cast<const char *>(&v), Size); }return instr.LoadFalse;executed 29939 times by 48 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadNull)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadNull)) }; typedef Instr::instr_LoadNull DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadNull;return instr.LoadNull;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadNull), reinterpret_cast<const char *>(&v), Size); }return instr.LoadNull;executed 88923 times by 29 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadUndefined)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadUndefined)) }; typedef Instr::instr_LoadUndefined DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadUndefined;return instr.LoadUndefined;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadUndefined), reinterpret_cast<const char *>(&v), Size); }return instr.LoadUndefined;executed 1079519 times by 92 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadInt)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadInt)) }; typedef Instr::instr_LoadInt DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadInt;return instr.LoadInt;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadInt), reinterpret_cast<const char *>(&v), Size); }return instr.LoadInt;executed 285689 times by 78 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadRuntimeString)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadRuntimeString)) }; typedef Instr::instr_LoadRuntimeString DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadRuntimeString;return instr.LoadRuntimeString;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadRuntimeString), reinterpret_cast<const char *>(&v), Size); }return instr.LoadRuntimeString;executed 3238054 times by 89 tests: }; template<> struct InstrMeta<int(Instr::Type::MoveConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_MoveConst)) }; typedef Instr::instr_MoveConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.MoveConst;return instr.MoveConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.MoveConst), reinterpret_cast<const char *>(&v), Size); }return instr.MoveConst;executed 632782 times by 65 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadReg)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadReg)) }; typedef Instr::instr_LoadReg DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadReg;return instr.LoadReg;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadReg), reinterpret_cast<const char *>(&v), Size); }return instr.LoadReg;executed 4485007 times by 138 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreReg)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreReg)) }; typedef Instr::instr_StoreReg DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreReg;return instr.StoreReg;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreReg), reinterpret_cast<const char *>(&v), Size); }return instr.StoreReg;executed 8578511 times by 139 tests: }; template<> struct InstrMeta<int(Instr::Type::MoveReg)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_MoveReg)) }; typedef Instr::instr_MoveReg DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.MoveReg;return instr.MoveReg;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.MoveReg), reinterpret_cast<const char *>(&v), Size); }return instr.MoveReg;executed 2934796 times by 53 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadLocal)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadLocal)) }; typedef Instr::instr_LoadLocal DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadLocal;return instr.LoadLocal;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadLocal), reinterpret_cast<const char *>(&v), Size); }return instr.LoadLocal;executed 684355 times by 20 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreLocal)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreLocal)) }; typedef Instr::instr_StoreLocal DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreLocal;return instr.StoreLocal;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreLocal), reinterpret_cast<const char *>(&v), Size); }return instr.StoreLocal;executed 142538 times by 19 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadScopedLocal)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadScopedLocal)) }; typedef Instr::instr_LoadScopedLocal DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadScopedLocal;return instr.LoadScopedLocal;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadScopedLocal), reinterpret_cast<const char *>(&v), Size); }return instr.LoadScopedLocal;executed 24925 times by 8 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreScopedLocal)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreScopedLocal)) }; typedef Instr::instr_StoreScopedLocal DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreScopedLocal;return instr.StoreScopedLocal;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreScopedLocal), reinterpret_cast<const char *>(&v), Size); }return instr.StoreScopedLocal;executed 11006 times by 4 tests: }; template<> struct InstrMeta<int(Instr::Type::MoveRegExp)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_MoveRegExp)) }; typedef Instr::instr_MoveRegExp DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.MoveRegExp;return instr.MoveRegExp;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.MoveRegExp), reinterpret_cast<const char *>(&v), Size); }return instr.MoveRegExp;executed 1054781 times by 8 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadClosure)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadClosure)) }; typedef Instr::instr_LoadClosure DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadClosure;return instr.LoadClosure;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadClosure), reinterpret_cast<const char *>(&v), Size); }return instr.LoadClosure;executed 1036316 times by 32 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadName)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadName)) }; typedef Instr::instr_LoadName DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadName;return instr.LoadName;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadName), reinterpret_cast<const char *>(&v), Size); }return instr.LoadName;executed 1271367 times by 104 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadGlobalLookup)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadGlobalLookup)) }; typedef Instr::instr_LoadGlobalLookup DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadGlobalLookup;return instr.LoadGlobalLookup;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadGlobalLookup), reinterpret_cast<const char *>(&v), Size); }return instr.LoadGlobalLookup;executed 1805295 times by 6 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreNameSloppy)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreNameSloppy)) }; typedef Instr::instr_StoreNameSloppy DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreNameSloppy;return instr.StoreNameSloppy;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreNameSloppy), reinterpret_cast<const char *>(&v), Size); }return instr.StoreNameSloppy;executed 301027 times by 48 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreNameStrict)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreNameStrict)) }; typedef Instr::instr_StoreNameStrict DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreNameStrict;return instr.StoreNameStrict;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreNameStrict), reinterpret_cast<const char *>(&v), Size); }return instr.StoreNameStrict;executed 286029 times by 4 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadElement)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadElement)) }; typedef Instr::instr_LoadElement DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadElement;return instr.LoadElement;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadElement), reinterpret_cast<const char *>(&v), Size); }return instr.LoadElement;executed 71672 times by 32 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreElement)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreElement)) }; typedef Instr::instr_StoreElement DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreElement;return instr.StoreElement;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreElement), reinterpret_cast<const char *>(&v), Size); }return instr.StoreElement;executed 33443 times by 14 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadProperty)) }; typedef Instr::instr_LoadProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadProperty;return instr.LoadProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadProperty), reinterpret_cast<const char *>(&v), Size); }return instr.LoadProperty;executed 156012 times by 105 tests: }; template<> struct InstrMeta<int(Instr::Type::GetLookup)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_GetLookup)) }; typedef Instr::instr_GetLookup DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.GetLookup;return instr.GetLookup;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.GetLookup), reinterpret_cast<const char *>(&v), Size); }return instr.GetLookup;executed 1176927 times by 7 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreProperty)) }; typedef Instr::instr_StoreProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreProperty;return instr.StoreProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreProperty), reinterpret_cast<const char *>(&v), Size); }return instr.StoreProperty;executed 10286 times by 73 tests: }; template<> struct InstrMeta<int(Instr::Type::SetLookup)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_SetLookup)) }; typedef Instr::instr_SetLookup DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.SetLookup;return instr.SetLookup;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.SetLookup), reinterpret_cast<const char *>(&v), Size); }return instr.SetLookup;executed 594639 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::LoadSuperProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadSuperProperty)) }; typedef Instr::instr_LoadSuperProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadSuperProperty;return instr.LoadSuperProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadSuperProperty), reinterpret_cast<const char *>(&v), Size); }return instr.LoadSuperProperty;executed 328 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::StoreSuperProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreSuperProperty)) }; typedef Instr::instr_StoreSuperProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreSuperProperty;return instr.StoreSuperProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreSuperProperty), reinterpret_cast<const char *>(&v), Size); }return instr.StoreSuperProperty;executed 40 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::StoreScopeObjectProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreScopeObjectProperty)) }; typedef Instr::instr_StoreScopeObjectProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreScopeObjectProperty;return instr.StoreScopeObjectProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreScopeObjectProperty), reinterpret_cast<const char *>(&v), Size); }return instr.StoreScopeObjectProperty;executed 2010 times by 60 tests: }; template<> struct InstrMeta<int(Instr::Type::StoreContextObjectProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_StoreContextObjectProperty)) }; typedef Instr::instr_StoreContextObjectProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.StoreContextObjectProperty;return instr.StoreContextObjectProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.StoreContextObjectProperty), reinterpret_cast<const char *>(&v), Size); }return instr.StoreContextObjectProperty;never executed: }; template<> struct InstrMeta<int(Instr::Type::LoadScopeObjectProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadScopeObjectProperty)) }; typedef Instr::instr_LoadScopeObjectProperty DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.LoadScopeObjectProperty;return instr.LoadScopeObjectProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadScopeObjectProperty), reinterpret_cast<const char *>(&v), Size); }return instr.LoadScopeObjectProperty;executed 6819 times by 105 tests: }; template<> struct InstrMeta<int(Instr::Type::LoadContextObjectProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadContextObjectProperty)) }; typedef Instr::instr_LoadContextObjectProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadContextObjectProperty;return instr.LoadContextObjectProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadContextObjectProperty), reinterpret_cast<const char *>(&v), Size); }return instr.LoadContextObjectProperty;never executed: }; template<> struct InstrMeta<int(Instr::Type::LoadIdObject)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadIdObject)) }; typedef Instr::instr_LoadIdObject DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.LoadIdObject;return instr.LoadIdObject;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadIdObject), reinterpret_cast<const char *>(&v), Size); }return instr.LoadIdObject;never executed: }; template<> struct InstrMeta<int(Instr::Type::ConvertThisToObject)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_ConvertThisToObject)) }; typedef Instr::instr_ConvertThisToObject DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.ConvertThisToObject;return instr.ConvertThisToObject;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.ConvertThisToObject), reinterpret_cast<const char *>(&v), Size); }return instr.ConvertThisToObject;executed 86968 times by 16 tests: }; template<> struct InstrMeta<int(Instr::Type::ToObject)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_ToObject)) }; typedef Instr::instr_ToObject DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.ToObject;return instr.ToObject;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.ToObject), reinterpret_cast<const char *>(&v), Size); }return instr.ToObject;executed 1213 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::Jump)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Jump)) }; typedef Instr::instr_Jump DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Jump;return instr.Jump;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Jump), reinterpret_cast<const char *>(&v), Size); }return instr.Jump;executed 543824 times by 65 tests: }; template<> struct InstrMeta<int(Instr::Type::JumpTrue)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_JumpTrue)) }; typedef Instr::instr_JumpTrue DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.JumpTrue;return instr.JumpTrue;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.JumpTrue), reinterpret_cast<const char *>(&v), Size); }return instr.JumpTrue;executed 372034 times by 21 tests: }; template<> struct InstrMeta<int(Instr::Type::JumpFalse)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_JumpFalse)) }; typedef Instr::instr_JumpFalse DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.JumpFalse;return instr.JumpFalse;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.JumpFalse), reinterpret_cast<const char *>(&v), Size); }return instr.JumpFalse;executed 1372756 times by 71 tests: }; template<> struct InstrMeta<int(Instr::Type::JumpNoException)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_JumpNoException)) }; typedef Instr::instr_JumpNoException DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.JumpNoException;return instr.JumpNoException;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.JumpNoException), reinterpret_cast<const char *>(&v), Size); }return instr.JumpNoException;executed 113718 times by 21 tests: }; template<> struct InstrMeta<int(Instr::Type::JumpNotUndefined)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_JumpNotUndefined)) }; typedef Instr::instr_JumpNotUndefined DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.JumpNotUndefined;return instr.JumpNotUndefined;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.JumpNotUndefined), reinterpret_cast<const char *>(&v), Size); }return instr.JumpNotUndefined;executed 17384 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::CmpEqNull)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpEqNull)) }; typedef Instr::instr_CmpEqNull DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpEqNull;return instr.CmpEqNull;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpEqNull), reinterpret_cast<const char *>(&v), Size); }return instr.CmpEqNull;executed 491 times by 6 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpNeNull)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpNeNull)) }; typedef Instr::instr_CmpNeNull DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpNeNull;return instr.CmpNeNull;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpNeNull), reinterpret_cast<const char *>(&v), Size); }return instr.CmpNeNull;executed 80 times by 7 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpEqInt)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpEqInt)) }; typedef Instr::instr_CmpEqInt DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpEqInt;return instr.CmpEqInt;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpEqInt), reinterpret_cast<const char *>(&v), Size); }return instr.CmpEqInt;executed 1832 times by 21 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpNeInt)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpNeInt)) }; typedef Instr::instr_CmpNeInt DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpNeInt;return instr.CmpNeInt;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpNeInt), reinterpret_cast<const char *>(&v), Size); }return instr.CmpNeInt;executed 629 times by 16 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpEq)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpEq)) }; typedef Instr::instr_CmpEq DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpEq;return instr.CmpEq;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpEq), reinterpret_cast<const char *>(&v), Size); }return instr.CmpEq;executed 4062 times by 46 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpNe)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpNe)) }; typedef Instr::instr_CmpNe DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpNe;return instr.CmpNe;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpNe), reinterpret_cast<const char *>(&v), Size); }return instr.CmpNe;executed 2012 times by 29 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpGt)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpGt)) }; typedef Instr::instr_CmpGt DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpGt;return instr.CmpGt;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpGt), reinterpret_cast<const char *>(&v), Size); }return instr.CmpGt;executed 11388 times by 25 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpGe)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpGe)) }; typedef Instr::instr_CmpGe DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpGe;return instr.CmpGe;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpGe), reinterpret_cast<const char *>(&v), Size); }return instr.CmpGe;executed 2461 times by 12 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpLt)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpLt)) }; typedef Instr::instr_CmpLt DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpLt;return instr.CmpLt;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpLt), reinterpret_cast<const char *>(&v), Size); }return instr.CmpLt;executed 15529 times by 37 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpLe)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpLe)) }; typedef Instr::instr_CmpLe DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpLe;return instr.CmpLe;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpLe), reinterpret_cast<const char *>(&v), Size); }return instr.CmpLe;executed 3434 times by 11 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpStrictEqual)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpStrictEqual)) }; typedef Instr::instr_CmpStrictEqual DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpStrictEqual;return instr.CmpStrictEqual;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpStrictEqual), reinterpret_cast<const char *>(&v), Size); }return instr.CmpStrictEqual;executed 775943 times by 29 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpStrictNotEqual)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpStrictNotEqual)) }; typedef Instr::instr_CmpStrictNotEqual DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpStrictNotEqual;return instr.CmpStrictNotEqual;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpStrictNotEqual), reinterpret_cast<const char *>(&v), Size); }return instr.CmpStrictNotEqual;executed 631219 times by 17 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpIn)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpIn)) }; typedef Instr::instr_CmpIn DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpIn;return instr.CmpIn;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpIn), reinterpret_cast<const char *>(&v), Size); }return instr.CmpIn;executed 590 times by 9 tests: }; template<> struct InstrMeta<int(Instr::Type::CmpInstanceOf)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CmpInstanceOf)) }; typedef Instr::instr_CmpInstanceOf DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CmpInstanceOf;return instr.CmpInstanceOf;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CmpInstanceOf), reinterpret_cast<const char *>(&v), Size); }return instr.CmpInstanceOf;executed 21964 times by 15 tests: }; template<> struct InstrMeta<int(Instr::Type::UNot)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UNot)) }; typedef Instr::instr_UNot DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UNot;return instr.UNot;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UNot), reinterpret_cast<const char *>(&v), Size); }return instr.UNot;executed 193255 times by 33 tests: }; template<> struct InstrMeta<int(Instr::Type::UPlus)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UPlus)) }; typedef Instr::instr_UPlus DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UPlus;return instr.UPlus;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UPlus), reinterpret_cast<const char *>(&v), Size); }return instr.UPlus;executed 4499 times by 10 tests: }; template<> struct InstrMeta<int(Instr::Type::UMinus)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UMinus)) }; typedef Instr::instr_UMinus DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UMinus;return instr.UMinus;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UMinus), reinterpret_cast<const char *>(&v), Size); }return instr.UMinus;executed 3895 times by 10 tests: }; template<> struct InstrMeta<int(Instr::Type::UCompl)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UCompl)) }; typedef Instr::instr_UCompl DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UCompl;return instr.UCompl;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UCompl), reinterpret_cast<const char *>(&v), Size); }return instr.UCompl;executed 314 times by 4 tests: }; template<> struct InstrMeta<int(Instr::Type::Increment)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Increment)) }; typedef Instr::instr_Increment DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Increment;return instr.Increment;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Increment), reinterpret_cast<const char *>(&v), Size); }return instr.Increment;executed 18331 times by 45 tests: }; template<> struct InstrMeta<int(Instr::Type::Decrement)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Decrement)) }; typedef Instr::instr_Decrement DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Decrement;return instr.Decrement;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Decrement), reinterpret_cast<const char *>(&v), Size); }return instr.Decrement;executed 2674 times by 15 tests: }; template<> struct InstrMeta<int(Instr::Type::Add)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Add)) }; typedef Instr::instr_Add DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Add;return instr.Add;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Add), reinterpret_cast<const char *>(&v), Size); }return instr.Add;executed 2719596 times by 56 tests: }; template<> struct InstrMeta<int(Instr::Type::BitAnd)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_BitAnd)) }; typedef Instr::instr_BitAnd DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.BitAnd;return instr.BitAnd;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.BitAnd), reinterpret_cast<const char *>(&v), Size); }return instr.BitAnd;executed 742 times by 5 tests: }; template<> struct InstrMeta<int(Instr::Type::BitOr)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_BitOr)) }; typedef Instr::instr_BitOr DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.BitOr;return instr.BitOr;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.BitOr), reinterpret_cast<const char *>(&v), Size); }return instr.BitOr;executed 606 times by 10 tests: }; template<> struct InstrMeta<int(Instr::Type::BitXor)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_BitXor)) }; typedef Instr::instr_BitXor DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.BitXor;return instr.BitXor;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.BitXor), reinterpret_cast<const char *>(&v), Size); }return instr.BitXor;executed 548 times by 3 tests: }; template<> struct InstrMeta<int(Instr::Type::UShr)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UShr)) }; typedef Instr::instr_UShr DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UShr;return instr.UShr;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UShr), reinterpret_cast<const char *>(&v), Size); }return instr.UShr;executed 723 times by 3 tests: }; template<> struct InstrMeta<int(Instr::Type::Shr)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Shr)) }; typedef Instr::instr_Shr DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Shr;return instr.Shr;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Shr), reinterpret_cast<const char *>(&v), Size); }return instr.Shr;executed 748 times by 3 tests: }; template<> struct InstrMeta<int(Instr::Type::Shl)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Shl)) }; typedef Instr::instr_Shl DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Shl;return instr.Shl;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Shl), reinterpret_cast<const char *>(&v), Size); }return instr.Shl;executed 751 times by 3 tests: }; template<> struct InstrMeta<int(Instr::Type::BitAndConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_BitAndConst)) }; typedef Instr::instr_BitAndConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.BitAndConst;return instr.BitAndConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.BitAndConst), reinterpret_cast<const char *>(&v), Size); }return instr.BitAndConst;executed 1748 times by 3 tests: }; template<> struct InstrMeta<int(Instr::Type::BitOrConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_BitOrConst)) }; typedef Instr::instr_BitOrConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.BitOrConst;return instr.BitOrConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.BitOrConst), reinterpret_cast<const char *>(&v), Size); }return instr.BitOrConst;executed 556 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::BitXorConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_BitXorConst)) }; typedef Instr::instr_BitXorConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.BitXorConst;return instr.BitXorConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.BitXorConst), reinterpret_cast<const char *>(&v), Size); }return instr.BitXorConst;executed 548 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::UShrConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UShrConst)) }; typedef Instr::instr_UShrConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UShrConst;return instr.UShrConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UShrConst), reinterpret_cast<const char *>(&v), Size); }return instr.UShrConst;executed 18377 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::ShrConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_ShrConst)) }; typedef Instr::instr_ShrConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.ShrConst;return instr.ShrConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.ShrConst), reinterpret_cast<const char *>(&v), Size); }return instr.ShrConst;executed 17710 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::ShlConst)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_ShlConst)) }; typedef Instr::instr_ShlConst DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.ShlConst;return instr.ShlConst;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.ShlConst), reinterpret_cast<const char *>(&v), Size); }return instr.ShlConst;executed 17362 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::Exp)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Exp)) }; typedef Instr::instr_Exp DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Exp;return instr.Exp;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Exp), reinterpret_cast<const char *>(&v), Size); }return instr.Exp;executed 519 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::Mul)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Mul)) }; typedef Instr::instr_Mul DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Mul;return instr.Mul;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Mul), reinterpret_cast<const char *>(&v), Size); }return instr.Mul;executed 4234 times by 32 tests: }; template<> struct InstrMeta<int(Instr::Type::Div)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Div)) }; typedef Instr::instr_Div DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Div;return instr.Div;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Div), reinterpret_cast<const char *>(&v), Size); }return instr.Div;executed 174574 times by 31 tests: }; template<> struct InstrMeta<int(Instr::Type::Mod)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Mod)) }; typedef Instr::instr_Mod DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Mod;return instr.Mod;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Mod), reinterpret_cast<const char *>(&v), Size); }return instr.Mod;executed 2823 times by 10 tests: }; template<> struct InstrMeta<int(Instr::Type::Sub)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Sub)) }; typedef Instr::instr_Sub DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Sub;return instr.Sub;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Sub), reinterpret_cast<const char *>(&v), Size); }return instr.Sub;executed 5011 times by 31 tests: }; template<> struct InstrMeta<int(Instr::Type::CallValue)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallValue)) }; typedef Instr::instr_CallValue DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallValue;return instr.CallValue;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallValue), reinterpret_cast<const char *>(&v), Size); }return instr.CallValue;executed 112501 times by 16 tests: }; template<> struct InstrMeta<int(Instr::Type::CallProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallProperty)) }; typedef Instr::instr_CallProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallProperty;return instr.CallProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallProperty), reinterpret_cast<const char *>(&v), Size); }return instr.CallProperty;executed 55494 times by 82 tests: }; template<> struct InstrMeta<int(Instr::Type::CallPropertyLookup)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallPropertyLookup)) }; typedef Instr::instr_CallPropertyLookup DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallPropertyLookup;return instr.CallPropertyLookup;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallPropertyLookup), reinterpret_cast<const char *>(&v), Size); }return instr.CallPropertyLookup;executed 732967 times by 6 tests: }; template<> struct InstrMeta<int(Instr::Type::CallElement)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallElement)) }; typedef Instr::instr_CallElement DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallElement;return instr.CallElement;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallElement), reinterpret_cast<const char *>(&v), Size); }return instr.CallElement;executed 1110 times by 7 tests: }; template<> struct InstrMeta<int(Instr::Type::CallName)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallName)) }; typedef Instr::instr_CallName DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallName;return instr.CallName;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallName), reinterpret_cast<const char *>(&v), Size); }return instr.CallName;executed 40622 times by 47 tests: }; template<> struct InstrMeta<int(Instr::Type::CallPossiblyDirectEval)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallPossiblyDirectEval)) }; typedef Instr::instr_CallPossiblyDirectEval DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallPossiblyDirectEval;return instr.CallPossiblyDirectEval;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallPossiblyDirectEval), reinterpret_cast<const char *>(&v), Size); }return instr.CallPossiblyDirectEval;executed 12973 times by 8 tests: }; template<> struct InstrMeta<int(Instr::Type::CallGlobalLookup)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallGlobalLookup)) }; typedef Instr::instr_CallGlobalLookup DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallGlobalLookup;return instr.CallGlobalLookup;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallGlobalLookup), reinterpret_cast<const char *>(&v), Size); }return instr.CallGlobalLookup;executed 1594111 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::CallScopeObjectProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallScopeObjectProperty)) }; typedef Instr::instr_CallScopeObjectProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallScopeObjectProperty;return instr.CallScopeObjectProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallScopeObjectProperty), reinterpret_cast<const char *>(&v), Size); }return instr.CallScopeObjectProperty;executed 3116 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::CallContextObjectProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallContextObjectProperty)) }; typedef Instr::instr_CallContextObjectProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CallContextObjectProperty;return instr.CallContextObjectProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallContextObjectProperty), reinterpret_cast<const char *>(&v), Size); }return instr.CallContextObjectProperty;never executed: }; template<> struct InstrMeta<int(Instr::Type::CallWithSpread)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CallWithSpread)) }; typedef Instr::instr_CallWithSpread DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.CallWithSpread;return instr.CallWithSpread;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CallWithSpread), reinterpret_cast<const char *>(&v), Size); }return instr.CallWithSpread;executed 108 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::Construct)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Construct)) }; typedef Instr::instr_Construct DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Construct;return instr.Construct;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Construct), reinterpret_cast<const char *>(&v), Size); }return instr.Construct;executed 197832 times by 22 tests: }; template<> struct InstrMeta<int(Instr::Type::ConstructWithSpread)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_ConstructWithSpread)) }; typedef Instr::instr_ConstructWithSpread DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.ConstructWithSpread;return instr.ConstructWithSpread;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.ConstructWithSpread), reinterpret_cast<const char *>(&v), Size); }return instr.ConstructWithSpread;executed 176 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::SetUnwindHandler)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_SetUnwindHandler)) }; typedef Instr::instr_SetUnwindHandler DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.SetUnwindHandler;return instr.SetUnwindHandler;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.SetUnwindHandler), reinterpret_cast<const char *>(&v), Size); }return instr.SetUnwindHandler;executed 371077 times by 22 tests: }; template<> struct InstrMeta<int(Instr::Type::UnwindDispatch)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UnwindDispatch)) }; typedef Instr::instr_UnwindDispatch DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UnwindDispatch;return instr.UnwindDispatch;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UnwindDispatch), reinterpret_cast<const char *>(&v), Size); }return instr.UnwindDispatch;executed 129806 times by 22 tests: }; template<> struct InstrMeta<int(Instr::Type::UnwindToLabel)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_UnwindToLabel)) }; typedef Instr::instr_UnwindToLabel DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.UnwindToLabel;return instr.UnwindToLabel;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.UnwindToLabel), reinterpret_cast<const char *>(&v), Size); }return instr.UnwindToLabel;executed 83333 times by 13 tests: }; template<> struct InstrMeta<int(Instr::Type::ThrowException)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_ThrowException)) }; typedef Instr::instr_ThrowException DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.ThrowException;return instr.ThrowException;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.ThrowException), reinterpret_cast<const char *>(&v), Size); }return instr.ThrowException;executed 95971 times by 13 tests: }; template<> struct InstrMeta<int(Instr::Type::GetException)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_GetException)) }; typedef Instr::instr_GetException DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.GetException;return instr.GetException;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.GetException), reinterpret_cast<const char *>(&v), Size); }return instr.GetException;executed 826 times by 5 tests: }; template<> struct InstrMeta<int(Instr::Type::SetException)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_SetException)) }; typedef Instr::instr_SetException DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.SetException;return instr.SetException;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.SetException), reinterpret_cast<const char *>(&v), Size); }return instr.SetException;executed 826 times by 5 tests: }; template<> struct InstrMeta<int(Instr::Type::CreateCallContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CreateCallContext)) }; typedef Instr::instr_CreateCallContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CreateCallContext;return instr.CreateCallContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CreateCallContext), reinterpret_cast<const char *>(&v), Size); }return instr.CreateCallContext;executed 104318 times by 31 tests: }; template<> struct InstrMeta<int(Instr::Type::PushCatchContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_PushCatchContext)) }; typedef Instr::instr_PushCatchContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.PushCatchContext;return instr.PushCatchContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.PushCatchContext), reinterpret_cast<const char *>(&v), Size); }return instr.PushCatchContext;executed 112296 times by 21 tests: }; template<> struct InstrMeta<int(Instr::Type::PushWithContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_PushWithContext)) }; typedef Instr::instr_PushWithContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.PushWithContext;return instr.PushWithContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.PushWithContext), reinterpret_cast<const char *>(&v), Size); }return instr.PushWithContext;executed 817 times by 6 tests: }; template<> struct InstrMeta<int(Instr::Type::PushBlockContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_PushBlockContext)) }; typedef Instr::instr_PushBlockContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.PushBlockContext;return instr.PushBlockContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.PushBlockContext), reinterpret_cast<const char *>(&v), Size); }return instr.PushBlockContext;executed 890 times by 3 tests: }; template<> struct InstrMeta<int(Instr::Type::CloneBlockContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CloneBlockContext)) }; typedef Instr::instr_CloneBlockContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CloneBlockContext;return instr.CloneBlockContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CloneBlockContext), reinterpret_cast<const char *>(&v), Size); }return instr.CloneBlockContext;executed 46 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::PopContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_PopContext)) }; typedef Instr::instr_PopContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.PopContext;return instr.PopContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.PopContext), reinterpret_cast<const char *>(&v), Size); }return instr.PopContext;executed 219501 times by 33 tests: }; template<> struct InstrMeta<int(Instr::Type::GetIterator)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_GetIterator)) }; typedef Instr::instr_GetIterator DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.GetIterator;return instr.GetIterator;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.GetIterator), reinterpret_cast<const char *>(&v), Size); }return instr.GetIterator;executed 25110 times by 13 tests: }; template<> struct InstrMeta<int(Instr::Type::IteratorNext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_IteratorNext)) }; typedef Instr::instr_IteratorNext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.IteratorNext;return instr.IteratorNext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.IteratorNext), reinterpret_cast<const char *>(&v), Size); }return instr.IteratorNext;executed 27506 times by 13 tests: }; template<> struct InstrMeta<int(Instr::Type::IteratorClose)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_IteratorClose)) }; typedef Instr::instr_IteratorClose DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.IteratorClose;return instr.IteratorClose;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.IteratorClose), reinterpret_cast<const char *>(&v), Size); }return instr.IteratorClose;executed 11449 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::DestructureRestElement)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_DestructureRestElement)) }; typedef Instr::instr_DestructureRestElement DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.DestructureRestElement;return instr.DestructureRestElement;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.DestructureRestElement), reinterpret_cast<const char *>(&v), Size); }return instr.DestructureRestElement;executed 2805 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::DeleteProperty)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_DeleteProperty)) }; typedef Instr::instr_DeleteProperty DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.DeleteProperty;return instr.DeleteProperty;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.DeleteProperty), reinterpret_cast<const char *>(&v), Size); }return instr.DeleteProperty;executed 18907 times by 6 tests: }; template<> struct InstrMeta<int(Instr::Type::DeleteName)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_DeleteName)) }; typedef Instr::instr_DeleteName DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.DeleteName;return instr.DeleteName;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.DeleteName), reinterpret_cast<const char *>(&v), Size); }return instr.DeleteName;executed 177 times by 4 tests: }; template<> struct InstrMeta<int(Instr::Type::TypeofName)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_TypeofName)) }; typedef Instr::instr_TypeofName DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.TypeofName;return instr.TypeofName;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.TypeofName), reinterpret_cast<const char *>(&v), Size); }return instr.TypeofName;executed 3177 times by 6 tests: }; template<> struct InstrMeta<int(Instr::Type::TypeofValue)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_TypeofValue)) }; typedef Instr::instr_TypeofValue DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.TypeofValue;return instr.TypeofValue;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.TypeofValue), reinterpret_cast<const char *>(&v), Size); }return instr.TypeofValue;executed 186455 times by 10 tests: }; template<> struct InstrMeta<int(Instr::Type::DeclareVar)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_DeclareVar)) }; typedef Instr::instr_DeclareVar DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.DeclareVar;return instr.DeclareVar;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.DeclareVar), reinterpret_cast<const char *>(&v), Size); }return instr.DeclareVar;executed 518113 times by 20 tests: }; template<> struct InstrMeta<int(Instr::Type::DefineArray)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_DefineArray)) }; typedef Instr::instr_DefineArray DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.DefineArray;return instr.DefineArray;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.DefineArray), reinterpret_cast<const char *>(&v), Size); }return instr.DefineArray;executed 45136 times by 46 tests: }; template<> struct InstrMeta<int(Instr::Type::DefineObjectLiteral)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_DefineObjectLiteral)) }; typedef Instr::instr_DefineObjectLiteral DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.DefineObjectLiteral;return instr.DefineObjectLiteral;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.DefineObjectLiteral), reinterpret_cast<const char *>(&v), Size); }return instr.DefineObjectLiteral;executed 71484 times by 36 tests: }; template<> struct InstrMeta<int(Instr::Type::CreateMappedArgumentsObject)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CreateMappedArgumentsObject)) }; typedef Instr::instr_CreateMappedArgumentsObject DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CreateMappedArgumentsObject;return instr.CreateMappedArgumentsObject;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CreateMappedArgumentsObject), reinterpret_cast<const char *>(&v), Size); }return instr.CreateMappedArgumentsObject;executed 9678 times by 16 tests: }; template<> struct InstrMeta<int(Instr::Type::CreateUnmappedArgumentsObject)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CreateUnmappedArgumentsObject)) }; typedef Instr::instr_CreateUnmappedArgumentsObject DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CreateUnmappedArgumentsObject;return instr.CreateUnmappedArgumentsObject;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CreateUnmappedArgumentsObject), reinterpret_cast<const char *>(&v), Size); }return instr.CreateUnmappedArgumentsObject;executed 6113 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::CreateRestParameter)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CreateRestParameter)) }; typedef Instr::instr_CreateRestParameter DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CreateRestParameter;return instr.CreateRestParameter;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CreateRestParameter), reinterpret_cast<const char *>(&v), Size); }return instr.CreateRestParameter;executed 244 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::LoadQmlContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadQmlContext)) }; typedef Instr::instr_LoadQmlContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadQmlContext;return instr.LoadQmlContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadQmlContext), reinterpret_cast<const char *>(&v), Size); }return instr.LoadQmlContext;never executed: }; template<> struct InstrMeta<int(Instr::Type::LoadQmlImportedScripts)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadQmlImportedScripts)) }; typedef Instr::instr_LoadQmlImportedScripts DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.LoadQmlImportedScripts;return instr.LoadQmlImportedScripts;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadQmlImportedScripts), reinterpret_cast<const char *>(&v), Size); }return instr.LoadQmlImportedScripts;never executed: }; template<> struct InstrMeta<int(Instr::Type::Yield)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Yield)) }; typedef Instr::instr_Yield DataType; static const DataType &data(const Instr &instr) { returnend of blocknever executed: instr.Yield;return instr.Yield;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Yield), reinterpret_cast<const char *>(&v), Size); }return instr.Yield;executed 11546 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::Resume)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Resume)) }; typedef Instr::instr_Resume DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Resume;return instr.Resume;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Resume), reinterpret_cast<const char *>(&v), Size); }return instr.Resume;executed 2061 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::CreateClass)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_CreateClass)) }; typedef Instr::instr_CreateClass DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.CreateClass;return instr.CreateClass;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.CreateClass), reinterpret_cast<const char *>(&v), Size); }return instr.CreateClass;executed 9258 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::LoadSuperConstructor)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_LoadSuperConstructor)) }; typedef Instr::instr_LoadSuperConstructor DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.LoadSuperConstructor;return instr.LoadSuperConstructor;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.LoadSuperConstructor), reinterpret_cast<const char *>(&v), Size); }return instr.LoadSuperConstructor;executed 455 times by 1 test: }; template<> struct InstrMeta<int(Instr::Type::PushScriptContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_PushScriptContext)) }; typedef Instr::instr_PushScriptContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.PushScriptContext;return instr.PushScriptContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.PushScriptContext), reinterpret_cast<const char *>(&v), Size); }return instr.PushScriptContext;executed 5126 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::PopScriptContext)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_PopScriptContext)) }; typedef Instr::instr_PopScriptContext DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.PopScriptContext;return instr.PopScriptContext;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.PopScriptContext), reinterpret_cast<const char *>(&v), Size); }return instr.PopScriptContext;executed 5174 times by 2 tests: }; template<> struct InstrMeta<int(Instr::Type::Debug)> { enum { Size = (sizeof(QV4::Moth::Instr::instr_Debug)) }; typedef Instr::instr_Debug DataType; static const DataType &data(const Instr &instr) { returnend of blockExecuted by:
never executed: instr.Debug;return instr.Debug;never executed: } static void setData(Instr &instr, const DataType &v) { memcpy(reinterpret_cast<char *>(&instr.Debug), reinterpret_cast<const char *>(&v), Size); }return instr.Debug;executed 714 times by 2 tests: };;end of blockExecuted by:
| 0-8578511 | ||||||
| 89 | - | |||||||
| 90 | - | |||||||
| 91 | #pragma GCC diagnostic pop | - | ||||||
| 92 | - | |||||||
| 93 | - | |||||||
| 94 | template<int InstrType> | - | ||||||
| 95 | class InstrData : public InstrMeta<InstrType>::DataType | - | ||||||
| 96 | { | - | ||||||
| 97 | }; | - | ||||||
| 98 | - | |||||||
| 99 | struct Instruction { | - | ||||||
| 100 | - | |||||||
| 101 | typedef InstrData<int(Instr::Type::Nop)> Nop; typedef InstrData<int(Instr::Type::Ret)> Ret; typedef InstrData<int(Instr::Type::LoadConst)> LoadConst; typedef InstrData<int(Instr::Type::LoadZero)> LoadZero; typedef InstrData<int(Instr::Type::LoadTrue)> LoadTrue; typedef InstrData<int(Instr::Type::LoadFalse)> LoadFalse; typedef InstrData<int(Instr::Type::LoadNull)> LoadNull; typedef InstrData<int(Instr::Type::LoadUndefined)> LoadUndefined; typedef InstrData<int(Instr::Type::LoadInt)> LoadInt; typedef InstrData<int(Instr::Type::LoadRuntimeString)> LoadRuntimeString; typedef InstrData<int(Instr::Type::MoveConst)> MoveConst; typedef InstrData<int(Instr::Type::LoadReg)> LoadReg; typedef InstrData<int(Instr::Type::StoreReg)> StoreReg; typedef InstrData<int(Instr::Type::MoveReg)> MoveReg; typedef InstrData<int(Instr::Type::LoadLocal)> LoadLocal; typedef InstrData<int(Instr::Type::StoreLocal)> StoreLocal; typedef InstrData<int(Instr::Type::LoadScopedLocal)> LoadScopedLocal; typedef InstrData<int(Instr::Type::StoreScopedLocal)> StoreScopedLocal; typedef InstrData<int(Instr::Type::MoveRegExp)> MoveRegExp; typedef InstrData<int(Instr::Type::LoadClosure)> LoadClosure; typedef InstrData<int(Instr::Type::LoadName)> LoadName; typedef InstrData<int(Instr::Type::LoadGlobalLookup)> LoadGlobalLookup; typedef InstrData<int(Instr::Type::StoreNameSloppy)> StoreNameSloppy; typedef InstrData<int(Instr::Type::StoreNameStrict)> StoreNameStrict; typedef InstrData<int(Instr::Type::LoadElement)> LoadElement; typedef InstrData<int(Instr::Type::StoreElement)> StoreElement; typedef InstrData<int(Instr::Type::LoadProperty)> LoadProperty; typedef InstrData<int(Instr::Type::GetLookup)> GetLookup; typedef InstrData<int(Instr::Type::StoreProperty)> StoreProperty; typedef InstrData<int(Instr::Type::SetLookup)> SetLookup; typedef InstrData<int(Instr::Type::LoadSuperProperty)> LoadSuperProperty; typedef InstrData<int(Instr::Type::StoreSuperProperty)> StoreSuperProperty; typedef InstrData<int(Instr::Type::StoreScopeObjectProperty)> StoreScopeObjectProperty; typedef InstrData<int(Instr::Type::StoreContextObjectProperty)> StoreContextObjectProperty; typedef InstrData<int(Instr::Type::LoadScopeObjectProperty)> LoadScopeObjectProperty; typedef InstrData<int(Instr::Type::LoadContextObjectProperty)> LoadContextObjectProperty; typedef InstrData<int(Instr::Type::LoadIdObject)> LoadIdObject; typedef InstrData<int(Instr::Type::ConvertThisToObject)> ConvertThisToObject; typedef InstrData<int(Instr::Type::ToObject)> ToObject; typedef InstrData<int(Instr::Type::Jump)> Jump; typedef InstrData<int(Instr::Type::JumpTrue)> JumpTrue; typedef InstrData<int(Instr::Type::JumpFalse)> JumpFalse; typedef InstrData<int(Instr::Type::JumpNoException)> JumpNoException; typedef InstrData<int(Instr::Type::JumpNotUndefined)> JumpNotUndefined; typedef InstrData<int(Instr::Type::CmpEqNull)> CmpEqNull; typedef InstrData<int(Instr::Type::CmpNeNull)> CmpNeNull; typedef InstrData<int(Instr::Type::CmpEqInt)> CmpEqInt; typedef InstrData<int(Instr::Type::CmpNeInt)> CmpNeInt; typedef InstrData<int(Instr::Type::CmpEq)> CmpEq; typedef InstrData<int(Instr::Type::CmpNe)> CmpNe; typedef InstrData<int(Instr::Type::CmpGt)> CmpGt; typedef InstrData<int(Instr::Type::CmpGe)> CmpGe; typedef InstrData<int(Instr::Type::CmpLt)> CmpLt; typedef InstrData<int(Instr::Type::CmpLe)> CmpLe; typedef InstrData<int(Instr::Type::CmpStrictEqual)> CmpStrictEqual; typedef InstrData<int(Instr::Type::CmpStrictNotEqual)> CmpStrictNotEqual; typedef InstrData<int(Instr::Type::CmpIn)> CmpIn; typedef InstrData<int(Instr::Type::CmpInstanceOf)> CmpInstanceOf; typedef InstrData<int(Instr::Type::UNot)> UNot; typedef InstrData<int(Instr::Type::UPlus)> UPlus; typedef InstrData<int(Instr::Type::UMinus)> UMinus; typedef InstrData<int(Instr::Type::UCompl)> UCompl; typedef InstrData<int(Instr::Type::Increment)> Increment; typedef InstrData<int(Instr::Type::Decrement)> Decrement; typedef InstrData<int(Instr::Type::Add)> Add; typedef InstrData<int(Instr::Type::BitAnd)> BitAnd; typedef InstrData<int(Instr::Type::BitOr)> BitOr; typedef InstrData<int(Instr::Type::BitXor)> BitXor; typedef InstrData<int(Instr::Type::UShr)> UShr; typedef InstrData<int(Instr::Type::Shr)> Shr; typedef InstrData<int(Instr::Type::Shl)> Shl; typedef InstrData<int(Instr::Type::BitAndConst)> BitAndConst; typedef InstrData<int(Instr::Type::BitOrConst)> BitOrConst; typedef InstrData<int(Instr::Type::BitXorConst)> BitXorConst; typedef InstrData<int(Instr::Type::UShrConst)> UShrConst; typedef InstrData<int(Instr::Type::ShrConst)> ShrConst; typedef InstrData<int(Instr::Type::ShlConst)> ShlConst; typedef InstrData<int(Instr::Type::Exp)> Exp; typedef InstrData<int(Instr::Type::Mul)> Mul; typedef InstrData<int(Instr::Type::Div)> Div; typedef InstrData<int(Instr::Type::Mod)> Mod; typedef InstrData<int(Instr::Type::Sub)> Sub; typedef InstrData<int(Instr::Type::CallValue)> CallValue; typedef InstrData<int(Instr::Type::CallProperty)> CallProperty; typedef InstrData<int(Instr::Type::CallPropertyLookup)> CallPropertyLookup; typedef InstrData<int(Instr::Type::CallElement)> CallElement; typedef InstrData<int(Instr::Type::CallName)> CallName; typedef InstrData<int(Instr::Type::CallPossiblyDirectEval)> CallPossiblyDirectEval; typedef InstrData<int(Instr::Type::CallGlobalLookup)> CallGlobalLookup; typedef InstrData<int(Instr::Type::CallScopeObjectProperty)> CallScopeObjectProperty; typedef InstrData<int(Instr::Type::CallContextObjectProperty)> CallContextObjectProperty; typedef InstrData<int(Instr::Type::CallWithSpread)> CallWithSpread; typedef InstrData<int(Instr::Type::Construct)> Construct; typedef InstrData<int(Instr::Type::ConstructWithSpread)> ConstructWithSpread; typedef InstrData<int(Instr::Type::SetUnwindHandler)> SetUnwindHandler; typedef InstrData<int(Instr::Type::UnwindDispatch)> UnwindDispatch; typedef InstrData<int(Instr::Type::UnwindToLabel)> UnwindToLabel; typedef InstrData<int(Instr::Type::ThrowException)> ThrowException; typedef InstrData<int(Instr::Type::GetException)> GetException; typedef InstrData<int(Instr::Type::SetException)> SetException; typedef InstrData<int(Instr::Type::CreateCallContext)> CreateCallContext; typedef InstrData<int(Instr::Type::PushCatchContext)> PushCatchContext; typedef InstrData<int(Instr::Type::PushWithContext)> PushWithContext; typedef InstrData<int(Instr::Type::PushBlockContext)> PushBlockContext; typedef InstrData<int(Instr::Type::CloneBlockContext)> CloneBlockContext; typedef InstrData<int(Instr::Type::PopContext)> PopContext; typedef InstrData<int(Instr::Type::GetIterator)> GetIterator; typedef InstrData<int(Instr::Type::IteratorNext)> IteratorNext; typedef InstrData<int(Instr::Type::IteratorClose)> IteratorClose; typedef InstrData<int(Instr::Type::DestructureRestElement)> DestructureRestElement; typedef InstrData<int(Instr::Type::DeleteProperty)> DeleteProperty; typedef InstrData<int(Instr::Type::DeleteName)> DeleteName; typedef InstrData<int(Instr::Type::TypeofName)> TypeofName; typedef InstrData<int(Instr::Type::TypeofValue)> TypeofValue; typedef InstrData<int(Instr::Type::DeclareVar)> DeclareVar; typedef InstrData<int(Instr::Type::DefineArray)> DefineArray; typedef InstrData<int(Instr::Type::DefineObjectLiteral)> DefineObjectLiteral; typedef InstrData<int(Instr::Type::CreateMappedArgumentsObject)> CreateMappedArgumentsObject; typedef InstrData<int(Instr::Type::CreateUnmappedArgumentsObject)> CreateUnmappedArgumentsObject; typedef InstrData<int(Instr::Type::CreateRestParameter)> CreateRestParameter; typedef InstrData<int(Instr::Type::LoadQmlContext)> LoadQmlContext; typedef InstrData<int(Instr::Type::LoadQmlImportedScripts)> LoadQmlImportedScripts; typedef InstrData<int(Instr::Type::Yield)> Yield; typedef InstrData<int(Instr::Type::Resume)> Resume; typedef InstrData<int(Instr::Type::CreateClass)> CreateClass; typedef InstrData<int(Instr::Type::LoadSuperConstructor)> LoadSuperConstructor; typedef InstrData<int(Instr::Type::PushScriptContext)> PushScriptContext; typedef InstrData<int(Instr::Type::PopScriptContext)> PopScriptContext; typedef InstrData<int(Instr::Type::Debug)> Debug; | - | ||||||
| 102 | - | |||||||
| 103 | private: | - | ||||||
| 104 | Instruction(); | - | ||||||
| 105 | }; | - | ||||||
| 106 | - | |||||||
| 107 | } | - | ||||||
| 108 | } | - | ||||||
| 109 | - | |||||||
| 110 | - | |||||||
| Switch to Source code | Preprocessed file |